internal/

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.

events.go — the closed core EventKind vocabulary (additive).

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 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 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 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 adjudicator is the in-process DOS reference monitor — the v0.1 realization of the Adjudicator seam.

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 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 agent is the HOST-SIDE agentic loop and the wire servers that expose it.

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 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 agenticbench folds the #868 agentic benchmark artifacts into one parent gate.

Package agentreadinessscore grades the ONE thing the sibling scorecards do not: can an autonomous coding agent — Claude Code, OpenAI Codex, Cursor, an MCP client — (1) DISCOVER fak, (2) WANT to adopt and build on it, and (3) do so effectively and easily? The other inward sticks grade a surface a human reviewer cares about (the tree's shape, the Go module, a doc's prose); this one grades agent attractiveness, the number an agent-first project lives or dies on.

Package agentsindex is a stdlib-only, tier-1 view over AGENTS.md (issue #3535, epic #3229).

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 agenttopo declares agent communication topology over comm.Group.

Package ailuminate encodes the scoping + go/no-go contract for entering MLCommons AILuminate (v1.1) as a model+guardrail "AI system" SUT.

Package amdgpu probes AMD GPU facts on Windows through PowerShell.

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 antipattern is the UNIFYING REGISTRY for the agentic-dev anti-patterns whose common shape is "work that did not convert into global, user-useful progress": work REDONE that was already done (repetition), and work LANDED but connected to nothing (lost / orphaned).

Package apihostprobe probes OpenAI-compatible API hosts and folds readiness and acceptance reports for the API-host bridge surface.

Package appversion resolves the FAK application version from build identity or from a VERSION marker that belongs to the running executable.

Package architest is the kernel's machine-checked architecture contract.

Package assumecheck is the pure assumption-audit kernel (#3819, epic #3818 C1): "an assumption an agent (or operator) is relying on" as a first-class, checkable value instead of an unexamined belief baked into a prompt or a loop.

Package astquery is a structural (AST-shape) search over Go source with metavariables — the "match code by shape, not text" seam (#3438, epic #3434).

Package atif projects fak's redacted trajectory Turn corpus onto ATIF — the Agent Trajectory Interchange Format — so a fak session round-trips to a portable, eval-pipeline-consumable artifact.

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 auditpane is the one rollup over the tree's many tools/*_audit.py auditors.

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 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 balance renders the NIGHT-BALANCE surface: the two forces a self-driving run must hold in equilibrium, side by side, in one glanceable readout.

Package benchauthority is the typed, in-binary source of truth for the PRIMARY benchmark NUMBERS fak claims — the "what" half of the benchmark discipline, the twin of internal/benchcatalog (which registers the benchmarks that PRODUCE the numbers, not the numbers themselves).

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 benchckpt is the shared per-cell write-ahead checkpoint the compute-bench executors (modelbench, fanrun, and the fanbench/turnbench siblings that follow) write through so a crash at cell N does not discard the cells 1..N-1 already measured.

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 benchids generates a deterministic stream of synthetic token IDs for the benchmark command mains.

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 benchloop folds fak's benchmark surfaces into one read-only control loop.

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 benchruns reads benchmark catalog entries and resolves run details from the committed experiment artifacts.

Package benchscore scans benchmark result artifacts and folds model-level score summaries plus validation issues.

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 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 blastradius is the pure JOIN at the heart of blast-radius containment (epic #2712, W3): given a broken package, it computes the AFFECTED SET — the live leases and queued issues whose declared tree intersects the broken package's DEPENDENCY blast radius (the package plus every package that transitively imports it).

Package blob is the v0.1 default backend behind every abi.Ref: a content-addressed (sha256) in-memory blob store.

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 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 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 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 branchrole reads fak's branch-role contract from dos.toml.

Package brittleness is the DETECTOR-AND-CAPTURE for seams that "got lucky": process/commit/test outcomes that WORKED but only by timing, chance, or a symptom-patch that did not hold -- and the regressions those seams throw.

Package browseraction normalizes browser/computer-use action traces into fak tool-call mediation reports.

Package buildwitness is a structural CI guard: it fails when the primary binary package (cmd/fak) does not compile with the DEFAULT build tags.

Package cachemeta defines the metadata contract for first-class cache entries.

Bloom-filter reuse-POTENTIAL estimator (#3396) — the probabilistic sibling of the realized-reuse tap in cacheobs.go.

Package cacheprice is the ONE source of truth for the provider prompt-cache price multipliers — the cost of a cached-prefix READ or WRITE relative to a base (uncached) input token.

Package cachesweep turns fak's radixkv prefix-cache engine into a budget→reuse SWEEP: replay ONE recorded prefix-access trace at each of N cached-token budgets PLUS one unbounded pass, and report the reuse-vs-budget curve, the infinite-cache theoretical ceiling, and the smallest budget that reaches 99% of it (the ROI knee).

Package cachevalue folds the persisted cache-savings ledger (docs/nightrun/cache-savings.jsonl) into per-session cache-efficiency metrics and flags regressions (#1992).

Package cachevalueledger provides a durable, append-only ledger for cache-value observations from fak sessions (run/guard/serve).

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 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 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 cadencereport is the consolidated regular-cadence report -- one fold over the four cadence dimensions an operator tracks: scores, maturity, work-done, and releases.

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 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 capindex defines protocol-blind capability cards and lazy resolvers for skills, MCP tools, A2A agents, and other attachable affordances.

Package capindexgw holds the gateway-backed capindex Resolvers (MCP tools, A2A methods).

Package catchupscore folds the dev system's "how caught up are we?" question into one control-pane scorecard.

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 chatops is the inbound chatops DOOR — epic #2259 leaf C4 (#2264): the pure fold that turns one raw Slack message into either a closed-grammar verb the fleet operator controls understand, or a structured refusal.

Package chatopsdetach is the pure detached-execution decision kernel for chatops ACT verbs (#2265, epic #2259 leaf C5): the fold that turns an inbound "dispatch this" command into ack-now / witnessed-completion / stall-escalation routing, without ever touching the wire, a git repo, or a clock.

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 checkpointscore is fak's deterministic WIP-checkpoint readiness scorecard.

Package choicetriage decenters the human from a surfaced "choice".

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 clonescan is the forward, authoring-time half of fak's clone detector.

Package closebatch groups witnessed-closeable issues into dry-run batches before any live close mutates GitHub.

Package closureaudit is a pure, stdlib-only port of the grader half of tools/issue_closure_audit.py (#1406): it binds commits to issue numbers from commit text (ClassifyRefs / RefsFromCommits), then grades each issue into exactly one witness bucket (Grade / Build) using the per-SHA `dos commit-audit` verdicts the caller supplies.

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 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 codegraph is a directed code knowledge-graph with breadth-first traversal — the "what reaches / what depends on this" seam (#3439, epic #3434, the capstone).

Package codelint is language-server packs: lint agent-written code (Go/Python/CUDA/JSON) off the hot path.

Package codesearch composes the epic #3434 code-intelligence primitives into one user-facing engine — the wiring that turns four otherwise-orphan libraries into a tool someone can actually run:

analytics.go — the #4767 half of this leaf: native Codex critical-path and TYPED tool-outcome analytics over the same rollout store the #4785 lifecycle fold reads.

Package codexmcphealth diagnoses fak's Codex MCP transport/server health and reports the next recovery step instead of retrying a dead connection.

Package codexmemory is a READ-ONLY diagnostic over an OpenAI Codex home (default ~/.codex).

Package cohort is a fail-closed cohort shrink and agreement leaf over comm.Group.

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 commitintent defines the durable, pure queue record that sits before an effectful fak commit drain.

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.

reclaim.go adds the DECISION half of stale-git-index.lock recovery on top of the read-only observer in status.go.

Package commitrollup plans compatible commit-intent batches without touching git.

Package commitsubject reports witness-gradeable commit subject coverage.

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 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 compute is the hardware-abstraction seam (HAL) for the in-kernel forward pass.

Package computeadmit is the ONE shared admission kernel over the compute partitioners (#3269, parent epic #3259) — the compute-plane twin of regionadmit.Decide / laneadmit.Decide.

Package conceptbench implements the dos-refereed grader for the concept benchmark (#2732, epic #2721).

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 conflationscore is the Go port of tools/conflation_scorecard.py -- the anti-conflation / provenance-honesty stick.

Package conformance is the standalone, third-party-runnable fak safety-conformance suite (#453).

Package contextq is the on-demand context materializer over CDB images.

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 corelocks parses and validates a DECLARATIVE core-lock taxonomy: lock classes and reason tokens carried as DATA, not a hand-coded table.

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 ctxknobs is the MANUAL-OVERLAY COUNTER — R1 of the zero-knob automatic-context epic (#2199, epic #2198; spine docs/notes/CONCEPT-AUTOMATIC-CONTEXT-2026-07-01.md).

Package ctxmmu — the disposition-minting gate (issue #1598).

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 ctxplans is the CONTEXT-PLAN-REQUIRED advisory lint (R4, #2202, epic #2198).

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 cvregress is per-session cache-efficiency (hit% + write-amp) regression flagging over the cache-savings ledger axes.

Package deadlineadmit is a pure, tier-1 admission policy.

Package deepseekbench is the pure core of the DeepSeek V4 Pro/Flash TTFT/TPOT/context-scaling SCORECARD (#3014, under the DeepSeek V4 support program #3006; complements the self-host wire-readiness runbook #3013).

Package deepseekv4kv is a pure, weight-free block-accounting fixture for the DeepSeek V4 heterogeneous KV plane and its on-disk prefix-reuse policies.

Package deepseekv4moe is a pure, weight-free synthetic model of DeepSeek V4 Pro's all-MoE dispatch, used to lock the dispatch contract and compare naive per-expert scheduling against grouped/fused scheduling.

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 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 demo is the pure logic behind the `fak demo` verb: fak's canonical 60-second offline proof, run end-to-end through the REAL kernel.

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 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 deploymanifest defines the unified `fak.toml` all-in-one deployment manifest (issue #3421, Workstream E of epic #3256) and its fail-closed loader.

Package devexmeter is dev-ex friction meter and RSI close gate.

Package devindex is queryable self-index over fak's own dev facts (lanes/leaves + doc map): query, don't survey.

Package dispatchaging is the deterministic anti-starvation term the fak issue-dispatch order is missing: given a set of READY (already dispatchable) work units, it decides which one a worker should pick FIRST when raw priority alone would let a low-priority unit wait forever.

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 dispatchauto is auto-size a multi-account dispatch wave from live ceilings; pure fold, no I/O.

Package dispatchconservation is the worker-unit conservation ledger for the dispatch fleet: over a window, units_spent = accounted + leaked, so a worker-unit that dies ungraded reads as a LEAK count, not as silence.

compute_contend.go — the EXPORTED reuse surface of the compute-claim collision machinery (#3269, parent epic #3259): the same class/mode/range fold that computeCollision prices fan-out candidates with, factored out so the shared compute admission kernel (internal/computeadmit) and any compute placer answer with IDENTICAL contention semantics instead of growing a private twin.

Package dispatchpost posts the RESULT of a background code-dispatch run — the thing `fak loop run -- <cmd>` produces — to a Slack "dispatch" channel.

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 dispatchtick holds the pure contract for one issue-resolution dispatch tick.

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 dogfoodissues is the backlog bridge from the recent-feature dogfood scorecard to a stable, deduplicated GitHub issue per ACTION item.

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 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 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 dojopost posts fak DOJO calibration rollups — the latest prediction-vs-reality run and the across-tick calibration trend — to a Slack dojo channel.

Package doomloop is the two-axis doom-loop classifier: it folds a live worker's effort-vs-verified-progress sample window into a closed verdict and a graduated, reversible-first correction recommendation.

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 dormancysim is the deterministic time-travel harness for fak's dormancy organs (epic #1178, Phase 3, #1192): the acceptance substrate every other child is exercised through.

Package dropin is the canonical drop-in wire resolution + known-agent registry shared by fak guard and the entry-point demo.

Package dsparity is the pure, OFFLINE parity-harness SPECIFICATION for future DeepSeek-V4 native kernels (#3021, under the DeepSeek V4 support program #3006; sibling of the docs/deepseek/*.md and docs/notes/DEEPSEEK-V4-*.md plan notes).

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.

Delivery adjudication: the egress capability floor for OUTBOUND PLATFORM MESSAGES (Telegram/Discord/Slack/WhatsApp/Signal), issue #2850 (Track D, #2834).

Package egresslist is the nuanced, adblock-style site allow/block layer that sits ABOVE the hardwired cloud-metadata egress floor (internal/egressfloor) and BELOW the restrictive WebFetch research allowlist.

Package egressrefresh re-fetches the bundled egress filter lists (internal/egresslist/lists) from their recorded provenance URLs, re-normalizes them through the SAME ingest path the kernel compiles, and rewrites the checked-in artifact plus its pinned checksum.

Package engine is the inference-engine seam (the EngineDriver).

Package enginecache binds cachemeta's remote invalidation directives to documented serving-engine control endpoints.

Package envconfiglint is the CONFIG_NOT_ENV ratchet: the durable gate that keeps behavioral configuration out of the environment (issue #2863, Track G / epic #2834).

Package epicprogress resolves how complete a GitHub epic is from its children, via a provenance-honest priority chain.

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 escalation defines fak.escalation.v1 — the ONE typed escalation packet every interrupt surface shares (#2271, epic #2269, spine R2 of docs/notes/CONCEPT-NO-BABYSITTING-2026-07-01.md).

Package evebridge is the pure core of the fak <-> eve bridge (#2600).

Package eveimport is the read-only importer for issue #2606: it folds saved Eve observability artifacts — an NDJSON session stream and/or OpenTelemetry spans carrying `eve.*` / `$eve.*` attributes — into fak's session-ledger row shape, so an Eve run can be debugged with fak's witnessed-status discipline instead of dashboard-only inspection.

Package eveparity is the CI-runnable witness for issue #2605: it runs a fixture Eve-shaped eval suite once "raw" (against a fixture model directly) and once "fak-routed" (the same suite with every model call flowing through fak's real gateway proxy), then proves the two arms agree — and, crucially, that fak never silently downgrades a hard Eve gate FAILURE into a soft observation.

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 executionroute composes harness, model, and session routing into one inspectable execution decision without collapsing their distinct policies.

Package experiments reads experiment ledgers and finds model/backend overlap across the repo's benchmark and research registries.

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 findingsink is a general-purpose sink seam for scorecard findings: a producer folds its debt into neutral Findings and hands them to a Sink, without knowing whether the sink is a terminal dry-run, a durable local ledger, or GitHub issues.

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 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 the Claude Code, Codex, and opencode product families.

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 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 fleetmemory is the cross-agent lessons ledger (#2141) and its write-time duplicate guard (#2142).

Package fleetmetrics is a pure duration-percentile fold over worker-session records.

Package fleetmon is the evidence-derived monitor, janitor, ledger, and replacement engine for a headless-worker fleet run (#1856–#1859).

Package fleetpane folds fleet loop, process, and host checks into the operator control-pane view.

Package fleetreap provides bounded retention and footprint measurement for per-session fleet artifacts.

Package fleetsim is a deterministic synthetic-ledger model for the "safe 400 GitHub issues/hour parallel-agent throughput" program (issue #1819, fleet-400iph).

Package fleetspine is the networking-aware self-discovery spine for the fleet-control pane.

Package fleetverify is a THROWAWAY compile-verification of the operator.go fleet helpers, isolated from the concurrently-churning cmd/fak (package main) so the exact loopfleet/loopmgr API usage type-checks against the real APIs with zero duplicate-symbol risk.

Package flock is a cross-platform, non-blocking advisory file lock on an open *os.File.

Package flowcredit is the receiver-granted credit ledger for cross-node KV block transfer backpressure (#5293, epic #5289 mooncake-study).

Package focusscore grades the ONE thing the per-objective trajectory-control fold cannot see: is the fleet as a whole CONVERGING on its live goal, or fanning out too broad — many objectives declared active at once, detours run past budget while their parents sit paused, open objectives drifting or stalled instead of moving?

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 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 gardenbundle is the garden bundle -- one default-on fold over the repo's read-only gardening passes.

Delivery send path: the live gateway seam that puts an OUTBOUND PLATFORM MESSAGE (Telegram/Discord/Slack/WhatsApp/Signal) through the egress capability floor (internal/egressfloor) before it leaves the box.

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 ggufload parses GGUF metadata and tensor directories for off-path model loading.

Package ghexec builds deadlined `gh` invocations (issue #3473).

fsmonitor_repair.go — the OPERATOR-INVOKED repair half of the fsmonitor-drift story (#5068, follow-up to #4603's detector).

Package glm52prefillsweep is the GLM-5.2 pure-fak PREFILL-latency sweep driver — the Go port of the retired tools/glm52_prefill_sweep.py (lever L9; #3085/#3086).

Package goalpark persists long provider Retry-After waits outside a worker's active context budget and arbitrates exactly-once resume after the reset.

Package godfileceiling is the ratcheting god-file LOC ceiling gate (issue #2898, Hermes-inspiration epic #2871).

Package godsplitplan is the boundary + hazard planner for a behavior-preserving Go split — the Go port of the retired tools/godsplit_plan.py (fak pythongate).

Package gpulease is a machine-wide advisory lease so that only one GPU-heavy process loads a model at a time.

Package grafanapost posts fak #grafana-channel cards — exported Grafana snapshots and long-lived dashboard / debug links — to a Slack channel.

compile.go is the tokenizer-aware schema->mask compiler: the minimal native spine of the structured-generation backlog (#2596), the exact follow-on CLAIMS.md names after #929 shipped the model-side sink.

Package growthgate classifies unbounded-growth "bloat" fingerprints from a cheap census of append-only artifacts — the pure, OS-independent heart of `fak growthgate`.

Package guard holds the agent-spawn containment seam for `fak guard`.

Package guardaccuracy folds a labeled command corpus through the real guard reversibility classifier and scores its accuracy: the false-positive rate (benign calls the guard escalated) and the false-negative rate (dangerous calls the guard let through as reversible).

Package guardaudit bounds repo-local guard audit journals only after an independently verified logvault mirror proves their bytes are durable.

Package guardcompile compiles one authoring-time model extraction into a review-only policy patch.

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 guardcorpus folds a guarded session's decision-journal rows into the durable, policy-attributable GUARD-SESSION dataset: one SessionRecord per session plus the replayable, redacted Example rows a training/regression consumer needs (docs/GUARD-SESSION-DATASET-PLAN.md).

Package guardrotate is the pure decision core for `fak guard`'s cooldown-aware seat selection.

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 guardrsi scores guard-verdict quality and proposes replayable recursive-improvement candidates for weak denial buckets.

Package guardsessions is the local, queryable INDEX of `fak guard` sessions — the durable answer to "which guard sessions are running (or recently ran) on this box, and how do I reference one?".

Package guardtrace is the end-to-end test/replay harness for `fak guard`.

Package guardvars holds the canonical wire shapes shared by the /debug/vars PRODUCER (internal/gateway) and the `fak info` CONSUMER (cmd/fak) for the blocks both sides once hand-copied field-for-field.

Package guideddecode is slice-1 of the constrained tool-JSON decoding gap (issue #26): a SOUND, byte-level compiler that constrains a model's decode to a valid tool-call envelope.

Package harnessprofile is the declarative HarnessProfile descriptor + built-in registry that fak guard drives detection, repoint, credential, and rotation from.

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 harvest is the LabelRow harvester — the data-collection rung of the compiled defender-side loop.

Package headlesslint is the sensor-side dual of internal/choicetriage.

Package headroom is the context-compression seam: a pluggable Compressor area (headroom/native/noop plugins) folded into the result path as a ResultAdmitter.

Package heavinessscore is the operator-heaviness / steering-effort stick.

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 hooks runs the repo's commit-boundary gates IN ONE PROCESS.

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 hostplacement is a clean-room Go primitive for deterministic multi-host worker placement: a per-host headroom registry plus a pure placement function that picks the least-saturated, non-stale host to spill a dispatch worker onto, or falls back to staying local when no host is eligible.

Package hwgatelint is the sensor for the "local machine is the compute boundary" regression — the hardware-gate anti-pattern.

Package ideascout searches configured research, repository, and community feeds — arXiv (papers), GitHub (repos), Hacker News and Reddit (real-time trending discussion, newest-first via each platform's public API) — dedupes candidates against a seen-cache and the existing issue backlog, scores what survives, and emits triage-ready idea-scout issue plans.

Package idempotency gives retryable mutating tool ops a keyed, time-windowed dedup so a retried call after a hang/timeout is a safe no-op that returns the ORIGINAL result instead of double-applying (#2093, part of epic #2063).

Package ifc is the information-flow control layer — the CaMeL / FIDES complement to the lexical detectors (canon, normgate, ctxmmu).

Package intlist parses a string into a list of non-negative integers.

Package issuecatalog is the durable bridge from a reviewable catalog of performance-enablement gap rows to a stable, deduplicated GitHub issue per row.

Package issuecohort plans a whole BATCH of machine-created GitHub issue candidates at creation time, before any of them is synced to GitHub.

Package issuecontract reviews machine-created GitHub issue candidates before they enter the dispatch loop.

This file is the C9 calibration fold (#3046): join per-issue TIER DECISIONS to WITNESSED OUTCOMES and propose — never auto-apply — threshold changes to the routing policy.

Package issuededup is the write-time near-duplicate gate shared by every issue producer (#2504): given a candidate {title, body} and a backlog index built from cached, read-only `gh issue list` output, it returns advisory dup-risk verdicts {issue_number, similarity, matched_on} via simhash embed + TopK over the title and title+body axes.

Package issuefanout expands one shipped (or planned) working spine into the follow-on backlog the spine-first default demands: contract-ready QA, dogfooding, productization, observability, integration, docs, and release candidates.

Package issuehygiene is the pure KPI core behind `fak score issue-hygiene` -- the deterministic scorecard that grades how well the DEFAULT GitHub issue surface is CREATED and TAGGED, folded into one issue_hygiene_debt integer.

Package issuestriage is the tier-1 leaf that folds one surfaced issue action into its decenter-the-human disposition.

Package journal is the durable, append-only, tamper-evident DECISION JOURNAL — the regulated-audit (AUD) surface of the trust floor.

Package jsonlledger holds the shared JSONL-ledger row helpers the report packages (cadencereport, milestonereport, programreport, …) each used to copy-paste: Parse scans a JSONL ledger into typed rows, and LatestBefore finds the newest prior row.

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?"

Package knobcensus is the KNOB CENSUS — issue #2210, epic #2208 (meaningful-control plane).

Package knownbad is the pure fold core of the fleet-wide known-bad signature ledger — the load-bearing spine of the blast-radius containment epic (#2712).

Package knownenv is the pure core of the fleet-wide known-ENVIRONMENT-failure registry (#2144, epic #2136): a signature over TOOL OUTPUT — an error-text needle and/or an exit code — mapped to a not-your-fault verdict {known-env, owner/eta}.

Package kvbudget is a pure, GPU-free calculator for the KV-cache VRAM budget of concurrent GLM-5.2 (glm_moe_dsa) decode streams — the laptop-composable half of issue #3080 ("perf(serve): KV paging + context-budget tuning for concurrent GLM-5.2 streams within 206 GiB free VRAM").

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 l3kv is the durable L3 KV residency backend: StageSpan/RestoreSpan persist a demoted span by digest through the storedrv router (blobfs local stand-in + optional blobhttp remote pool) behind a durable span→content manifest (#1472).

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 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 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 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 learningdebt is the staleness->backlog bridge from the learning-docs scorecard to a cap-bounded, deduplicated GitHub triage issue per HARD teaching defect.

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 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 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 linkstate is the general "what state is my channel with a peer in right now?" record — the reusable comms-protocol view that the lab dispatch gate (internal/fleet) is one specialization of.

Package livecodebench adapts LiveCodeBench problem suites and run reports into fak-native shapes.

Package loaddebounce is a clean-room Go primitive that publishes a per-worker load signal only when it CHANGES (last==current dedup) and coalesces a burst of rapid changes behind a short reset-on-every-change debounce window so only the LATEST value survives to be emitted.

Package logvault captures fak's durable logs — the guard decision journals, the harness session stores, the dispatch/dos/loop ledgers — into one central vault directory, incrementally and tamper-evidently.

Package lookahead is the witness-gated Lesson core (#5204, child of #5202): the pure distillation of a fork-rollout's outcome into a Lesson whose assertive authority is bounded by the witness rung its evidence actually earned.

Package loopdrive parses the GOAL.md goal spec used by fak loop drive.

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.

loopbench measures what the witnessed exit-gate earns over a naive Ralph loop that terminates on the agent's own self-reported "done".

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 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 loopmgr records and summarizes long-running agent loop events.

Package looporphan is the pure duplicate-loop-supervisor reaper core: it folds a process census of loop/drainer SUPERVISORS into a closed keep/reap plan that never strands live work.

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 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 loopunblock is the GENERIC head-of-line unblocker for any worklist-draining loop — a normal loop, a super loop, or a meta-loop over super loops.

Package macbench runs the Mac gateway benchmark probes that feed nightrun.

Package macfit is models unified-memory capacity for many concurrent agents.

Package maputil holds small, generic map helpers that were previously copy-pasted across packages.

Package market validates discoverable extension descriptors without executing extension code.

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 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 maturity scores where each fak capability sits on its LIFECYCLE maturity ladder — and, crucially, what the next step to advance it is.

Package mcpfootprint prices the always-sent MCP tool-schema floor — the fixed per-turn token tax every registered tool adds to every API call, whether or not the tool is ever selected.

Package memgate checks whether a heavy model load should proceed under memory pressure.

Package memoryread renders the committed fleet memory mirror as a bounded digest.

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 memvaluescore is the unbounded memory-value scorecard — the memory sibling of the cache-value P&L.

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 metalgemm stub — the non-Apple-Silicon or cgo-disabled build.

budget.go — the per-task budget readout: what the current task has spent against a soft target, broken down by category, from real usage records (#2091).

Package microagent hosts many agent loops in ONE process: a worker pool that drives K concurrent Microagent.Step calls as goroutines, all sharing one in-process kernel gateway (#2002, epic #2000 M2).

Package milestoneburndown is the GitHub-milestone SCHEDULE dimension the milestone report never had: it reads the live milestones' own due dates, open/closed counts, and trailing closure velocity, then classifies each into a closed at-risk verdict (ON_TRACK / AT_RISK / OVERDUE / NO_DUE_DATE / DONE) with a projected drain date compared against the due date.

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 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 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 mlpscore grades epic #3256's first-lovable-cut contract from committed, machine-checkable witness manifests.

Package modedebt is the CONSUMER half of the mode-debt scorer/dispatcher pair (epic #4397, under harness-native #2387 / permission regimes #2389).

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 modelaccept evaluates versioned exact-model capability corpora without allowing missing evidence or aggregate averages to authorize a workload tier.

Package modelengine wires the in-kernel model (internal/model) into the kernel as a registered abi.EngineDriver under the id "inkernel".

Package modelladder is the shared model-ladder/registry infrastructure used by the live demos (cmd/ctxdemo, cmd/demorace).

Package modelops folds exact-model canary observations into capability-safe promotion, rollback, or hold decisions.

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 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 modelscore is the durable, pure registry of RAW model-capability evidence — the source-of-truth score shape that a tier policy (C3) and a dispatch chooser (C5) read, but that this package deliberately does NOT interpret.

Package modver derives a per-module version stamp from git history — the "version everything" spine.

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 mutationefficacy is a bounded, SOFT mutation-testing probe for the qa-process scorecard (#3845): it asks the one question coverage and assertion-strength cannot -- would the suite actually FAIL if the code were wrong? It applies a tiny set of standard operator mutants (flip a comparator, off-by-one a bound, swap +/-) to an allow-list of packages, runs each package's tests against the mutated source, and counts SURVIVORS: mutants the suite did not catch.

Package negframe implements fak-owned positive-state reframing.

Package newleaf generates architecture-compliant internal leaf skeletons and optional registration edits.

Package newmodel is new-model scaffolding command.

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 nodecompare folds per-node benchmark outputs into a cross-hardware table.

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 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 numfmt holds the small allocation-light numeric and environment formatting helpers that were copy-pasted across the kernel.

Package operatorbrief folds existing control-pane reports into one operator-facing brief.

Package operatorquestion is harness-agnostic operator question normalization.

Package operatorresolve is evidence-first operator question resolver.

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 opttarget is the declarative target layer of the RSI optimization fuser (epic #1279).

Package orphanscan is a small, syntactic detector for the "built but never wired up" smell: an unexported top-level function that is defined but referenced nowhere in its own package.

Package patchcommit commits one explicitly supplied unified patch through a temporary Git index.

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 pathutil holds small, dependency-free path helpers shared across the fak commands — chiefly normalizing user-supplied path flags before they reach the filesystem.

Package planaudit audits coarse completion signals in plan documents.

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 planresolve is oracle-driven plan content adjudicator.

amendment.go is the PolicyKnob amendment-class registry (#5171, epic #5170, Track A): the single machine-checked source of truth stating, for every exported adjudicator.Policy field (and each non-field compiled-in floor element), its amendment class — who, if anyone, may move that knob, and in which direction.

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 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 privatepath resolves private operator artifacts outside the public checkout.

env.go — the shared env-map → exec.Cmd.Env slice helper.

Package productscorecard folds product-facing rows into the durable product scorecard payload and report.

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 projectreport folds a GitHub ProjectsV2 board into the same schema/ok/verdict/finding/next_action control-pane envelope the milestone report uses (internal/milestonereport), so the board — "the fleet's single work pane" per .github/workflows/project-board-sync.yml — becomes an operator-visible dimension instead of a write-only sync target.

Package promalert parses an Alertmanager webhook payload (the v4 JSON an Alertmanager `webhook_config` POSTs) and renders it into compact Slack message text.

Package promptaudit scans system/developer/context prompt text for hidden control markers BEFORE they cross a model or cache boundary.

Package promptlint is the durable freshness monitor for the dispatch worker-issue prompts.

Package promptmmu is the cache-prefix-preserving inbound prompt MMU: the INGRESS dual of the result-side ctxmmu.

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 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 pythongate is the NEW-PYTHON-TOOL ratchet: the durable gate that makes the project's de-Python push gradual and self-sustaining.

Package qaprocessscore holds the QA-process scorecard's KPI folds -- the E-testing-quality track's "is our test process honest?" signals.

Package quality is the runnable spine of the "missing middle" validation ladder (epic #4509): the layer between primitive correctness tests (too local to catch a fluent-but-wrong decode) and end benchmarks (too coarse and late to localize an engine-caused regression).

Package questionledger is the deterministic labeling authority for the /question-loop skill's ledger, docs/questions/asked.jsonl.

Cross-tier contiguous-prefix assembly accounting (#3379).

Package ratelimit is the throughput/cost governor: the adjudicator that turns the already-plumbed RATE_LIMITED reason into an actual enforcer.

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 refactorverify proves a god-split / code-motion refactor dropped NO top-level definition — the Go port of the retired tools/refactor_verify.py (fak pythongate).

Package refutil holds foundation-level helpers for materializing ABI refs.

Package region provides a typed, in-process one-sided shared window over abi.Ref values.

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 registrations is the "built-in driver list" (the Linux defconfig).

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.

Rung G2 (issue #1889): the two-phase arm/fire rotation state machine — the control-flow core that keeps a relay from ever rotating mid-action.

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 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 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 renameconcept plans — and mechanically applies — a CONCEPT rename across the whole tree: the "dgxbridge -> slackbridge" class of change, where one name is baked into directory names, Go identifiers, docs prose, config lanes, ignore rules, and historical data records, each wanting a different treatment.

cdmap.go — the drive-stripped-workspace `cd` rung of the repo-guard PreToolUse hook (worker path-mapping; driver: the 2026-07-09 trajectory audit).

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.

crashdrive.go — the crash-journal ↔ identity-map join.

Package resumebackoff contains the pure resume-storm containment fold.

Package resumemetrics is the PROCESS-GLOBAL expvar surface for the resume/heal watchdog (#3803).

Package roofline folds the GLM-5.2 DGX-drive run artifacts into a single current-vs-80%target-vs-ceiling dashboard — one row per drive lane, keyed to the theoretical-ceiling note.

Package rsiloop closes fak's recursive-self-improvement loop.

Package rsl is the git Reference State Log — a forge-independent, append-only, hash-chained record of every observed trunk ref transition.

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 rungobs is the passive rung-decision distribution counter — the aggregate observability dual of `fak preflight --explain`.

Package safecommit is the EXECUTOR half of the shared-trunk commit discipline that internal/gitgate only declares defensively.

Package safesync is safe fast-forward sync for dirty shared worktrees.

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 scdiff is the shared diff-scoping seam for shift-left scorecards.

Package scmbridge completes the Windows supervision plane (#4756, parent #4748, foundation #4749): ONE desired-state / read-back contract shared by the SCM LocalService control plane and the Scheduled-Task S4U / InteractiveToken recovery bridge, so machine services, interactive agents, boot recovery, and crash recovery cannot diverge or double-launch.

Package scoreboard posts fak status — scorecard results, scores, run events — to a Slack "scoreboard" channel.

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 seatpark is a pure, bounded park-and-retry fold for the no-seat transient (REFUSE_NO_ACCOUNT).

Package secretgate is the execution-time, on-discovery SECRET rung (epic #880, pillar [B], issue #884).

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 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.

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.

Package sensecheck is the "does this actually make sense?" side-car.

JSON-LD parsing and shape helpers.

Package servicelease is the lease / generation / incarnation fencing layer over the fak.service.v1 contract (#4752, parent #4748, foundation #4749).

Package serviceledger is the portable append-only observed-state event ledger for services (#4753, parent #4748, depends on #4749).

Package servicespec defines the portable fak.service.v1 desired-state and restart-semantics contract (#4749, parent #4748).

Rung H6 (issue #1899): the session-side wiring of the relay driver's Recontinue seam.

Package sessionaudit audits Claude Code session-transcript JSONL files.

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 —

Issue #4144 (wiring half): the production on-disk wiring for relay's cross-host WARM-resume seam.

Package sessionjournal is the crash-survivable session-registration journal: an append-only JSONL lifecycle log (open / beat / close, each boot-stamped) plus the pure fold that classifies every recorded session LIVE / CRASHED / STALE / CLOSED against the machine BOOT EPOCH — so a system-wide infra crash (a Windows-update reboot, or a WindowsTerminal 0xc0000005 that kills every terminal at one instant) can be recovered from: the fleet re-enumerated and the crashed set resumed.

Package sessionledger is the durable per-trace hash chain the gateway and the RSI loop append to at every turn boundary.

Package sessionobs scores the OBSERVABILITY of our own coding-session data for RSI loops.

Package sessionreplay freezes one turn's regime-conditioned harness decision into a checked-in, deterministically replayable regression fixture (#4425, part of the managed-turn epic #4107).

Package sessionreset builds the "human-like" carryover a fresh session is seeded with when a long-running session crosses its token budget.

Package sessionsearch is witnessed cross-session recall over the guard session journal (#2913, parent #2908 — porting the design of Hermes' tools/session_search_tool.py to fak's evidence discipline).

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 sessionsteer is the steering + admission half of the zero-knob automatic-context doctrine (epic #2198, spine #3512).

Package shadowgit attributes every file write an agent makes to the exact step that made it, without touching the repo the agent is working in.

Package sharedtask is the in-memory reference fold for collaborative task records.

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.

Package signals defines plain-English BEHAVIORAL signals over an agent's turns — the behavioral complement to the structural anti-pattern detectors.

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 skilleffectiveness measures whether each Claude Code skill in `.claude/skills/*/SKILL.md` is BUILT to be effective -- discoverable (a frontmatter description), triggerable (an explicit "use when"/"use to"), affordable (per-load-tier word budgets), and reachable through the queried loader (a queryable, paging, in-sync capability catalog) -- and folds the gaps into the control-pane payload every fak scorecard emits.

Package skillenv tracks active skill versions and previews blast radius for hot-swap or rollback through the context and KV MMU surfaces.

Package skillfootprint prices the resident `.claude/skills` description floor — the always-shipped USERLAND slice of the token tax epic #3229 is shrinking — and holds the one-way ratchet that keeps it from growing unopposed (#5444).

Package skillvalue is the per-skill outcome-VALUE ledger — the value sibling of a usage counter (epic #2871, issue #2873).

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 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 slackmeta renders the common metadata line every fak Slack report carries.

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 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 snapshot is the uniform DUMP/RESTORE seam over fak's primitives.

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 spendrollup builds the cross-account `fak spend` rollup: one or more labeled spend figures per account, each carrying a valuation basis AND a WITNESSED/OBSERVED provenance label, plus a gate that fails any figure that forgets either label.

Package stallpage turns stallscan's reboot high-water decision into a durable, deduped operator page.

Package stallscan classifies whole-machine "stall" fingerprints from cheap, point-in-time system counters — the pure, OS-independent heart of `fak stallscan`.

Overlay MAINTENANCE loop (#5023): the tick that keeps the operator overlay current.

Package stepbaton is the pre-resume step-advice stamp: the durable, cross-restart carrier of the managed-context DECISION (a StepClass) captured while the trace is still live, so a resuming successor can read what the window pressure WAS before the trace rotated.

Package stepbatoncapture is the capture arm of the pre-resume step-advice stamp: the LIVE-side producer that reads the gateway's managed-context report while the trace is still alive and projects it into a durable stepbaton.Stamp.

Package steward is the steward population: a set of cheap, single-invariant validators that garden the kernel's journal.

Package stopfailure reads and settles DOS StopFailure breaker markers.

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 stripeload fans a single logical read across N byte-identical mirrors of the same file, sized by relative bandwidth (#4298).

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 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 supervisoragent defines the closed, payload-free INPUT CONTRACT that a supervisor agent consumes — fence #1 of the supervisor-seat doctrine (docs/notes/CONCEPT-SUPERVISOR-AGENT-SEAT-2026-07-13.md; epic #4477, leaf #4478).

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.

Package supportmaturityscore grades the covmatrix support rungs as a scorecard.

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 swebenchsota emits a dated SWE-bench SOTA reference snapshot extracted from the official leaderboard at https://www.swebench.com/.

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 systemservice renders service-manager definitions that keep fak's control plane outside terminal, compositor, and login-session process trees.

Package taskgraph folds a shared task journal into a typed task table with lease-gated claims.

Package taskidentity derives the canonical task identity for an agent session.

Package taskmgr is fak's process-local task manager concept.

Package taskvc binds the fleet's live Windows Scheduled Tasks to the installers that recreate them from version control — the reboot-survival half of the fleet's always-on posture (#3323).

Package terminalbench adapts Terminal-Bench-shaped command traces into fak command-boundary mediation reports.

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 tokencache is the persisted, content-addressed backing store for clonescan's per-file tokenization (#4330).

Package tokenizer is a tokenizer leaf for offline text/id conversion outside the model proof path.

Package toolcoverage audits which load-bearing tools modules have sibling tests.

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 toolproc is the kernel's process table for tool calls — the lifecycle spine for LONG-RUNNING tool use.

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 toolrollup folds a corpus of individual tool-call records into a per-tool-TYPE rollup — the read-only aggregate a session-analytics report renders (issue #2824, session-analytics C2).

Package toolsandbox adapts tau3/ToolSandbox-shaped policy-state traces into fak adjudication reports.

Package toolseq turns ordered per-session tool-call sequences into a tool-transition graph and its most common contiguous sequence variants — the "when do tools run, and in what order" view over a trajectory corpus.

Package toolshape fingerprints the SHAPE of one tool call's input and output — the redaction-safe structural record the session-analytics rollup chain consumes (epic #2822: this is C1, the keystone leaf C2/C4/C5 build on).

Package tooltrend folds a sequence of per-session tool-call buckets into a tool-mix + output-shape TREND — "which tools and which response shapes are rising or falling across N sessions" (issue #2826, session-analytics C4).

Package toon is a general JSON<->TOON (Token-Oriented Object Notation) codec whose correctness spine is a lossless, type-preserving round-trip: Decode(Encode(v)) deep- equals v for every value in the supported domain.

Package tracesink is a payload-bearing, IFC-labeled TRAJECTORY SINK.

Package trajctl is the trajectory-control objective, score-row, witness-rung, and JSONL ledger model.

Package trajctlhook is the impure call-site assembly that binds the pure trajctl turn-boundary fold (trajctl.Sample / trajctl.CompactionBoundary / trajctl.AppendSample) to a running session's host evidence.

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 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 trajquery lets an agent query its OWN trajectory corpus with a small SQL SELECT — and confines that query to an operator-defined scope by REWRITING it as a view, with a validator that proves the rewrite cannot leak rows outside the scope.

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 trendreport is the generic, consumer-agnostic ENVELOPE substrate the fak trend-reports share: the embeddable control-pane Envelope, the advisory gate whose only failing finding is the caller's *_unmeasured token, the per-tick direction word, and the JSONL append-line marshaller.

Package trigram is a pure-Go trigram postings index for substring and regex search over a document set — the tree + sibling-repo code-search seam (#3437, epic #3434).

Package trunkbuildprobe diagnoses *why* the release gate's ci-fast subset is red: is it a forgotten `git add`?

Package tuiplugin is the in-process extension seam for fak console panes.

changepoint.go — CHANGE-POINT DETECTION on the overhead/benchmark series (issue #1163, T7 of the self-tax assurance epic #1147).

Package turnkind classifies the latest user turn of an agentic conversation from message STRUCTURE alone — which content-block types the last user message carries, never their content.

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.

Package uiquality is the deterministic measuring stick for fak's terminal UI/UX quality — the surface the sibling scorecards never watch.

Package unwiredscore is the UNWIRED-CODE scorecard -- the recurring detector for the failure class the operator named "code complete but not wired into the default path".

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 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 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 vcachecal is the vCache observe & calibrate engine — milestone M1 of the vCache epic (issue #716).

Package vcachechain is the vCache chains & recall engine — milestone M4 of the vCache epic (issue #719).

Package vcacheextract sanitizes Codex session JSONL token telemetry.

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; and how many prefixes to warm inside rate-limit headroom.

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 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 vcachescore composes the vCache proof leaves into an agent-facing benchmark scorecard.

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 vcachestar is the vCache M2 star-anchor decision layer.

Package vcachewarm is the vCache M3 dedicated-warming decision layer.

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 verifierexposure ranks the gameability of fak's verification gates.

Package versionskew turns "I can't tell which fak is running" into a STRUCTURED, REFUSABLE version-skew verdict — the binary-provenance R2 witness (#3351, epic #2218 G2).

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 waiting is the R3 waiting-on-human queue (#2272, epic #2269): a pure fold over loop-event ledgers (internal/loopmgr) that turns each blocked-on-operator notify into one kernel object with age, held resources, deadline, and the safe default that fires on expiry — babysitting inverted: the fleet files tickets on the human, with deadlines.

Package watchdoghealth is the pure health-digest core for fak's DEFAULT watchdog monitors — the OS-scheduled fleet timers (resume, supervisor, dos-dispatch, stale-work-garden) that `cmd/fak`'s watchdog-autoheal keeps alive on every `fak serve` / `fak guard` boot.

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 wiki is the fak-native, witness-verified repo-wiki core (epic #4277, mined from AsyncFuncAI/deepwiki-open @ 16f35a0 — inspire, clean-room Go).

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 wipattr is the pure attribution core for #3874 (C2).

Package wipfence applies and removes the shared-trunk WIP build fence.

Package wiprecon is the pure reconciliation core for #3875 (C3).

Package wipref is the PURE core of `fak wip`: the working-tree checkpoint ledger that lives under refs/fak/wip/<session> — a sibling of the lease refs (internal/leaseref, refs/fak/locks/*).

Package wirescreen — ROADMAP for the "local model on the wire" proposer spine.

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.

Package workerenvelope defines a small machine-readable envelope for the RESULT a dispatch worker hands back when it finishes a GitHub issue.

Package workerworktree is the native Go port of tools/worker_worktree.py: the per-worker git worktree isolation primitive that the live dispatch spawn wires in for #3168.

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 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 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 worklog is the unified agent-work change feed (#3172): the "outbox insight" applied to agent work.

Package worktreewitness runs a command inside a transient detached git worktree pinned at origin/main, so the verdict reflects the trunk tip and NOT the caller's dirty working tree.

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 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 zaitask is bounded non-streaming Z.AI task runner.