---
title: "fak concept-disambiguation scorecard - is every similar-sounding concept crystal-clear"
description: "Inward naming scorecard: each confusable fak concept positioned on the grounded / defined / disambiguated / anchored axes, with one clarity verdict per concept. Two driven numbers: coverage (of the confusable concept space discovered in the tree) and disambiguation-debt."
---

# Concept-disambiguation scorecard - crystal clarity across similar-sounding names

The sibling scorecards grade fak's code, docs, and competitive standing. This one asks the question that bites a reader as the system grows: **of the massive, growing set of similar-sounding names (cache, vCache, KV cache, cachemeta, the provider prompt-cache), is each distinct concept crystal-clear - one canonical name, a written definition, and an explicit line drawn against the siblings it is confused with?** Every number below is re-derived by `tools/concept_disambiguation_scorecard.py` and cross-checked against the real tree (the grounding token must appear in the production corpus; the glossary anchor must exist; a `distinct_from` reference must resolve). No verdict is hand-typed.

> Regenerate: `python tools/concept_disambiguation_scorecard.py --markdown-dir docs/concept-disambiguation-scorecard`.

## Headline

| Metric | Value |
|---|---|
| **Score** | **96.9/100** (grade A) = 9.7/10 |
| **Coverage** | **95.3%** (880/923 confusable tree tokens positioned) |
| **Disambiguation-debt** | **43** (clarity 0 + coverage 43) |
| Crystal-clear concepts | 109 of 683 positioned |
| As of | 2026-06-29 (fak v0.34.0) |

> **Read this right.** The score is deliberately LOW at birth: it grades the WHOLE confusable namespace discovered in the tree, not the few concepts already catalogued. A low coverage number is the honest statement that most similar-sounding names are not yet disambiguated - which is exactly the debt this scorecard exists to retire.

## Standing at a glance

```text
concept-disambiguation chart - 683 concepts - score 96.9/100 (grade A) - disambiguation-debt 43

clarity ladder (count of concepts, best -> fog):
  * crystal       #####....................... 109
  o defined       ############################ 574
  ~ drifting      ............................ 0
  x colliding     ............................ 0
  . undocumented  ............................ 0

clarity mix by family (each cell = one concept):
  attention        oooooooooooooooooooooooooooooooooooooooooooooooooo (50 concept(s); 0 crystal)
  cache            **************ooooooooooooooooooooooooooooooooooooooooooooooooooooooo (69 concept(s); 14 crystal)
  context-ctx      ********oooooooooooooooooooooooooooooooooooooooooooooooooooo (60 concept(s); 8 crystal)
  cross-cluster    **************     (14 concept(s); 14 crystal)
  decision         ****ooooooooo      (13 concept(s); 4 crystal)
  evict            ***oooooooooooooo  (17 concept(s); 3 crystal)
  gateway-engine   ******ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo (79 concept(s); 6 crystal)
  guard-gate       ***********************ooooooooooooooooooooooooooooooooooo (58 concept(s); 23 crystal)
  layout           ***ooooo           (8 concept(s); 3 crystal)
  plan             ***ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo (82 concept(s); 3 crystal)
  policy-capability ******oooooooooooooooooooooooooooooooooooooooooooooo (52 concept(s); 6 crystal)
  pool             **ooooooooooo      (13 concept(s); 2 crystal)
  render-materialize ***ooooooooooooooooooooooooooooooooooooo (40 concept(s); 3 crystal)
  score-debt       ***oooooooooooooooo (19 concept(s); 3 crystal)
  session-runtime  *******oooooooooooooooooooooooooooooooooooooooooooooooooooooooo (63 concept(s); 7 crystal)
  support-maturity *****ooo           (8 concept(s); 5 crystal)
  witness-proof    *****ooooooooooooooooooooooooooooooooo (38 concept(s); 5 crystal)

coverage by family (positioned / discovered):
  plan             ##########################.. 132/141
  render-materialize #########################... 64/72
  session-runtime  #########################... 75/83
  score-debt       ########################.... 33/39
  guard-gate       ###########################. 89/93
  pool             ########################.... 18/21
  support-maturity #######################..... 15/18
  cache            ############################ 95/96
  policy-capability ############################ 63/64
  witness-proof    ###########################. 49/50
  attention        ############################ 57/57
  context-ctx      ############################ 69/69
  cross-cluster    ............................ 0/0
  decision         ############################ 15/15
  evict            ############################ 21/21
  gateway-engine   ############################ 114/114
  layout           ############################ 9/9

namespace coverage  [##############################..] 95.3%  (880/923 confusable tokens positioned)

legend: * crystal   o defined   ~ drifting   x colliding   . undocumented
```

## The clarity ladder

| Verdict | Means |
|---|---|
| * crystal | grounded + defined + a line drawn against siblings + that line anchored in a doc that exists |
| o defined | grounded + defined + a distinction line, but the line is not written in a discoverable doc |
| ~ drifting | grounded + defined, but no line drawn against its siblings (you know what it is, not what it is NOT) |
| x colliding | shares a canonical name with another concept - a true ambiguity, fixable only by a rename |
| . undocumented | appears in the tree, but the catalog gives no definition |

## The concepts (best verdict first)

| | Verdict | Kind | Family | Canonical - definition |
|---|---|---|---|---|
| * | crystal | subsystem | cache | **KV cache** - The kernel-owned raw attention state: per-position Key and Value tensor rows for the running model, supporting in-place eviction and prefix reuse. |
| * | crystal | subsystem | cache | **vCache** - The virtual API cache: a page-table abstraction that models a remote provider's prefix cache as virtual pages, with a manifest of canonical prefix chains and warmth belief. |
| * | crystal | subsystem | cache | **cachemeta** - The typed metadata contract (tier 1): owns no payloads, names reusable cache entries, and carries their validity / security / residency metadata and typed lookup verdicts. |
| * | crystal | concept | cache | **Prompt cache** - The upstream provider feature: a prefix cached via cache_control breakpoints, reported back as cache_read_input_tokens / cache_creation_input_tokens with a specific pricing multiplier. |
| * | crystal | metric | cache | **Provider cache** - A cachemeta entry on plane=provider: the OBSERVED telemetry record of what the provider's prompt cache did (read/creation token counts), marked non-re-serveable local proof. |
| * | crystal | config | cache | **cache_control** - The WRITE placement mechanism: the cache_control breakpoint you place to tell the provider where to cache a prefix. |
| * | crystal | metric | cache | **cache_read** - The READ telemetry: cache_read_input_tokens, what the provider reports it served from its cache rather than re-prefilling, billed at 0.1x base input. |
| * | crystal | metric | cache | **cache_creation_input_tokens** - The WRITE telemetry: cache_creation_input_tokens, what the provider reports it wrote to its cache on this call, billed at 1.25-2.0x base input depending on TTL. |
| * | crystal | subsystem | cache | **RadixKV** - A local token-trie data structure for fast prefix lookup that points INTO KV-cache spans, with materialization binding so cross-model spans are never reused. |
| * | crystal | subsystem | cache | **enginecache** - The adapter that translates cachemeta invalidation directives into a remote serving engine's control API (SGLang / vLLM prefix-cache reset or span evict). |
| * | crystal | subsystem | cache | **ViewCache** - Storage of materialized lossy projections (summary, QA, facts) over canonical memory pages, with FAULT / RECOMPUTE / HIT materialization verdicts. |
| * | crystal | subsystem | cache | **MemoryView** - The typed virtual-view contract binding a lossy derived projection (summary, graph) to its canonical raw-memory source by content digest + byte span, with provenance. |
| * | crystal | subsystem | cache | **Hardware-aware cache** - The placement POLICY that knows each tier's physical character (HBM / DRAM / NUMA-far / CXL / disk / remote) and demotes hot entries one tier colder under pressure. |
| * | crystal | symbol | cache | **KV transfer** - The migration DIRECTIVE emitted by hardware-aware placement: migrate / offload / restore / route a KV span between tiers. |
| * | crystal | subsystem | context-ctx | **context-MMU (ctxmmu)** - A write-time (post-tool) gate on tool RESULTS that decides if bytes enter context as-is, must be quarantined, or paged out to a pointer. |
| * | crystal | subsystem | context-ctx | **KV-MMU (kvmmu)** - The bridge that turns ctxmmu's logical quarantine verdict into a mechanical one by evicting K/V spans from the kernel's attention cache. |
| * | crystal | subsystem | context-ctx | **recall (session core dump)** - The persisted session core-dump: a page table over a content-addressed swap device, reloadable in a fresh process where a sealed page stays sealed. |
| * | crystal | concept | context-ctx | **compaction** - Provider prefix reuse on the wire: re-sending a byte-identical prefix so the provider serves it from its prompt cache instead of re-prefilling. |
| * | crystal | subsystem | context-ctx | **ctxplan (context planner)** - The planner that forecasts the bounded resident working set of context spans for a session and learns from witnessed attention outcomes. |
| * | crystal | subsystem | context-ctx | **contextq (materializer)** - On-demand context materializer: turns a search query into typed handles, materialization verdicts, omissions, and a render plan over CDB images. |
| * | crystal | symbol | context-ctx | **CtxViewPlanner** - Stateless, shared context-view planner wired to the gateway: one per server, shared across all requests, disabled by default. |
| * | crystal | symbol | context-ctx | **CompactionView** - A LOSSY compaction model: strips recovery handles off elided spans to show token savings without recoverability. |
| * | crystal | symbol | cross-cluster | **core-image manifest** - internal/recall's Manifest: the persisted core image of a finished session - the page table, the frozen quarantine-clearance state, and a frozen world-version marker, with the bytes themselves living in a sibling cas.json swap device. |
| * | crystal | symbol | cross-cluster | **policy manifest (on-disk JSON)** - internal/policy's Manifest: the on-disk capability-floor JSON an operator edits to configure the authorization intent - the abstract policy is compiled from this into an in-memory decision table. |
| * | crystal | symbol | cross-cluster | **session.Verdict** - internal/session's Verdict: what Decide returns to the agent turn loop at each boundary - Proceed (gate the next turn), MaxTokens (per-turn output cap), the drive State, Stop, and a closed Reason naming why the slot freed. |
| * | crystal | symbol | cross-cluster | **abi.Verdict (adjudication decision)** - internal/abi's Verdict: the discriminated-union adjudication decision type (Allow, Deny, Defer, Transform, Quarantine, RequireWitness) - the kernel's tool-call authorization decision surface. |
| * | crystal | symbol | cross-cluster | **compute backend** - internal/compute's Backend: the small whole-op HAL interface the forward loop targets (MatMul, RMSNorm, RoPE, Attention, NewKV ...), carrying a Tier capability probe and a CorrectnessClass; the CPU reference delegates to the model's exact arithmetic. |
| * | crystal | symbol | cross-cluster | **memq cell backend** - internal/memq's Backend: supplies memory cells (the page table as SAFE-metadata cells) and trust-gated byte access (Materialize pages one cell's bytes in through the trust gate); optional Tombstoner/Pruner add the durable mutations a backend chooses to support. |
| * | crystal | symbol | cross-cluster | **rung observer** - internal/rungobs's Observer: the passive rung-decision distribution counter - registered via abi.RegisterEmitter, it dedups by call SeqNo and histograms adjudication decisions (rung x kind x reason), read out with Snapshot. |
| * | crystal | symbol | cross-cluster | **cache-reuse observer** - internal/cacheobs's Observer: accumulates in-kernel KV-prefix reuse across served turns - prompt vs reused tokens, bucketed frozen/partial/cold by reuse ratio; the gateway scrapes the process-global Default. |
| * | crystal | symbol | cross-cluster | **planner candidate index** - internal/ctxplan's Index: the planner's candidate access path over a history store - an inverted token index, the append/recency order, and the durable set, maintained incrementally so a Probe returns a BOUNDED candidate set without rescanning all spans; metadata-only and deterministic. |
| * | crystal | symbol | cross-cluster | **simhash index** - internal/simhash's Index: an in-memory brute-force nearest-neighbor store - add (id, Vector, meta), then TopK(query, k) for the k most similar by cosine; a deterministic linear scan sized for a trajectory corpus of thousands of rows. |
| * | crystal | symbol | cross-cluster | **history-image store** - internal/ctxplan's Store: the history image the planner views - it supplies spans (SAFE metadata) and trust-gated byte access (Materialize is the gated page-in; a sealed span's bytes never cross the gate). A real deployment backs it with a recall core image or a memq backend. |
| * | crystal | symbol | cross-cluster | **blob CAS store** - internal/blob's Store: the content-addressed blob store (CAS) - digest->bytes with pin-aware bounded eviction (pinned digests, e.g. a vDSO tier-2 entry or a held quarantine handle, are never evicted), preserving the 'a cache hit equals a fresh call' invariant. |
| * | crystal | symbol | cross-cluster | **page-in refusal** - internal/ctxplan's Refusal: a selected span the trust gate declined to page in (sealed, or its bytes went missing) - reported to the caller, never rendered into the fresh history. |
| * | crystal | symbol | cross-cluster | **effect refusal** - internal/memq's Refusal: a cell an effect declined to touch (sealed / tombstoned / page-in refused) - recorded with a reason on the executor's result. |
| * | crystal | symbol | decision | **Decision (witness)** - Git evidence adjudication verdict with CONFIRMED/REFUTED/ABSTAIN labels |
| * | crystal | symbol | decision | **Decision (kernel)** - Tool-call verdict explanation trace showing why fak gave this verdict |
| * | crystal | symbol | decision | **Decision (scheduler)** - Loop admission advisory: whether to fire a scheduled loop now |
| * | crystal | symbol | decision | **Decision (shared-task)** - Shared-task execution state tracking and reconciliation record |
| * | crystal | symbol | evict | **evict (KV cache)** - Physical tensor span removal and RoPE re-rotation in KV cache for memory compaction |
| * | crystal | symbol | evict | **evict (playbook)** - Logical span pruning from rendered playbook under token budget |
| * | crystal | symbol | evict | **evict (session pool)** - Model instance eviction from a bounded LRU session pool |
| * | crystal | subsystem | gateway-engine | **kernel** - The fak core: the one implementation of abi.Kernel that coordinates adjudication, vDSO lookup, engine dispatch, and result admission across the tool-call path. |
| * | crystal | subsystem | gateway-engine | **gateway** - The kernel-adjudicated wire: the HTTP and MCP-RPC surface that fronts the kernel for non-Go clients, re-validating untrusted wire arguments before they reach it. |
| * | crystal | subsystem | gateway-engine | **engine** - The inference-engine seam (EngineDriver): the abstract backend interface the kernel dispatches allowed tool calls to (mock, HTTP upstream, fused in-kernel model). |
| * | crystal | subsystem | gateway-engine | **vDSO (tool vDSO)** - The tool vDSO: a local fast path (pure registry, content-addressed cache, static table) that answers a tool call with zero engine round-trip. |
| * | crystal | subsystem | gateway-engine | **model (in-kernel model)** - The in-kernel inference core: a pure-Go forward pass that runs chat token decode over a loaded GGUF checkpoint across several architectures and quant schemes. |
| * | crystal | symbol | gateway-engine | **engines registry** - The runtime registry (abi.Registry.engines) that maps engine IDs to their EngineDriver implementations: the kernel's dispatch table of all registered inference backends. |
| * | crystal | subsystem | guard-gate | **guard (fak guard kernel)** - The kernel itself: the in-process adjudication system that runs the decision chain and admits results, launched as `fak guard`. |
| * | crystal | concept | guard-gate | **gate (decision point)** - One decision point inside a guard, splitting by WHEN it fires: pre-call adjudicators, post-call result admitters, and git-hook gates. |
| * | crystal | symbol | guard-gate | **ResultAdmitter (post-call gate)** - A post-call gate: inspects a tool RESULT after execution and admits / quarantines / transforms it (ctxmmu, normgate, secretgate). |
| * | crystal | subsystem | guard-gate | **git-hook gate** - A commit-boundary check at git pre-commit / commit-msg (gate_brokenlink, gate_secretshape, gate_provenance, ...). |
| * | crystal | doc-term | guard-gate | **trunk guard** - A git hook that refuses commits made off the trunk (the OFF_TRUNK law), keeping all work on main. |
| * | crystal | subsystem | guard-gate | **repo guard (repoguard)** - A PreToolUse hook that refuses Bash/Write/Edit calls targeting paths outside the workspace tree. |
| * | crystal | subsystem | guard-gate | **gitgate (adjudicator)** - An adjudicator rung that prefilters git hazards (force-push, --no-verify, rebase -i) from shell tool calls at runtime. |
| * | crystal | subsystem | guard-gate | **shipgate (RSI promotion gate)** - An adjudicator that enforces RSI keep-or-revert verdicts on a code change based on witness-verified metric gain, never the candidate's own claim. |
| * | crystal | symbol | guard-gate | **StampGate (source-stamp result gate)** - A rank-20 ResultAdmitter that stamps every tool result's taint by SOURCE (trusted-local vs untrusted-egress) and clamps the result's ShareScope DOWNWARD. |
| * | crystal | symbol | guard-gate | **ScopeCeilingGate (scope-ceiling result gate)** - The result-side ShareScope CEILING gate (rank 21, above StampGate): confines cross-agent taint visibility to the declared scope boundary - the upward dual of StampGate's downward clamp. |
| * | crystal | symbol | guard-gate | **SinkGate (egress adjudicator)** - The egress adjudicator that DENIES a tool call whose arguments carry untrusted taint into a configured sink, governed by a GatedSinks policy. |
| * | crystal | doc-term | guard-gate | **sealed_by_trust_gate (trust-gate refusal)** - A trust-gate REFUSAL REASON code: a context page that is sealed/tombstoned cannot be demand-paged back in. |
| * | crystal | config | guard-gate | **StrictGatedSinks (strict egress-sink policy)** - The Policy preset that gates ALL egress sinks strictly: the GatedSinks configuration the SinkGate adjudicator enforces. |
| * | crystal | symbol | guard-gate | **mlp.gate_proj (FFN gate projection)** - The FFN/SwiGLU GATE projection weight in an MLP layer; after SiLU it is multiplied with up_proj, distinct from down_proj. |
| * | crystal | symbol | guard-gate | **q_gate_proj (linear-attn query gate)** - Qwen3.5 linear-attention QUERY gating projection (self_attn.q_gate_proj) in Gated-DeltaNet layers; the in_proj_z source absorbs it. |
| * | crystal | symbol | guard-gate | **gate_up_proj (fused SwiGLU gate+up)** - The FUSED gate+up projection (mlp.gate_up_proj.weight): gate_proj and up_proj concatenated into one tensor the loader splits. |
| * | crystal | symbol | guard-gate | **ffn_gate (GGUF FFN gate tensor)** - The GGUF tensor name for the FFN gate weight (ffn_gate.weight), canonicalized to mlp.gate_proj.weight on load. |
| * | crystal | config | guard-gate | **AttnOutputGate (attention output-gate flag)** - A Qwen3.5 CONFIG flag (attn_output_gate) enabling a sigmoid GATE on full-attention output logits. |
| * | crystal | symbol | guard-gate | **rmsNormGatedInPlace (gated RMSNorm)** - The Qwen3.5 gated-RMSNorm compute (Qwen3_5RMSNormGated): x = weight * rmsnorm(x) * silu(gate), applied in place. |
| * | crystal | symbol | guard-gate | **FoldedGate (KV-MMU result gate)** - The kvmmu gate that enforces the kernel's REGISTERED ResultAdmitter chain (most-restrictive-wins fold) over results before admitting them to the KV cache. |
| * | crystal | config | guard-gate | **DefaultGatedSinks (default egress-sink policy)** - The reasonable default GatedSinks configuration: gates EGRESS (exfiltration) and DESTRUCTIVE (irreversible mutation) sinks on session taint, but NOT EXEC (preserves dev work). |
| * | crystal | symbol | guard-gate | **ContractGate (contract validation gate)** - A named validation checkpoint in an official run contract (browseraction/terminalbench/toolsandbox) that gates promotion: candidate_task_ids, official_harness_pin, same_task_ids_required, etc. |
| * | crystal | concept | guard-gate | **guardrail (safety boundary)** - A safety boundary or constraint that prevents an AI system from taking harmful actions; often implemented as policy checks or refusal reasons. |
| * | crystal | symbol | layout | **Layout (tensor)** - Tensor element physical arrangement: RowMajor, ColMajor, or other ordering |
| * | crystal | symbol | layout | **Layout (ctxplan)** - Base/Current/Recent/Deep region profile for layout-aware planning |
| * | crystal | symbol | layout | **MLA KV layout seam** - Attention cache variant seam interface: standardKVLayout vs mlaKVLayout |
| * | crystal | symbol | plan | **Plan (planner)** - Planner's chosen resident view: selected set, elided set, and accounting |
| * | crystal | symbol | plan | **Plan (memq)** - Static pre-execution Explain output: pipeline steps, effects, and mutations |
| * | crystal | symbol | plan | **Candidate** - Scored span the planner may keep resident with cost, benefit, and density metrics |
| * | crystal | concept | policy-capability | **capability floor** - The deployable, declarative authorization layer that defines exactly which tools an agent may call by name, loaded as a JSON manifest at runtime. |
| * | crystal | config | policy-capability | **policy manifest** - The versioned JSON structure an operator edits to configure the capability floor, mapping 1:1 to adjudicator.Policy with deny reasons validated against the closed vocabulary. |
| * | crystal | subsystem | policy-capability | **adjudicator** - The in-process DOS reference monitor: the rung that folds a decision chain to prove a tool call allowed, denied, or deferred under the loaded policy. |
| * | crystal | symbol | policy-capability | **abi.Verdict** - The discriminated-union decision an adjudicator returns, keyed by kind (Allow, Deny, Defer, Transform, Quarantine, RequireWitness) with typed payloads. |
| * | crystal | symbol | policy-capability | **reason code** - The closed, additive vocabulary of refusal reasons (DEFAULT_DENY, POLICY_BLOCK, SELF_MODIFY, ...) that every deny verdict cites, never free text. |
| * | crystal | config | policy-capability | **posture (tool admission)** - The policy's default behavior after all provable refusal checks pass: PostureFailClosed (deny everything not allowed) or PostureAdmitAndLog (admit low-risk reads with forensic metadata). |
| * | crystal | symbol | pool | **Pool (session)** - Bounded-LRU session state container with a fixed ceiling on concurrent sessions |
| * | crystal | symbol | pool | **PoolProfile** - Pooling character of a residency tier describing host count, coherence model, and shareability |
| * | crystal | symbol | render-materialize | **RenderPlan** - Prompt-assembly layout: stable prefix of reused views plus volatile tail of raw faults |
| * | crystal | symbol | render-materialize | **RenderItem** - One cell materialized into context by OpRender query effect |
| * | crystal | symbol | render-materialize | **Rendered** - One span paged into fresh history through the trust gate |
| * | crystal | subsystem | score-debt | **scorecard** - One deterministic measurement of a surface that folds reality into a single *_debt integer plus an A-F grade (the family is documented in the scorecard skill). |
| * | crystal | subsystem | score-debt | **scorecard control pane** - The fold that sums every scorecard's *_debt into one portfolio number with a pinned ratchet that reds only on a regression above baseline. |
| * | crystal | metric | score-debt | **disambiguation-debt** - This scorecard's integer: clarity defects of positioned concepts plus coverage gaps (confusable tree tokens with no row). |
| * | crystal | subsystem | session-runtime | **Session** - The full drive record for one served run (run-state, budget, priority, pace), keyed by TraceID and persisting across turns. |
| * | crystal | concept | session-runtime | **Turn** - One model round-trip within a session: the agent submits input, the model generates output, and results are admitted to context. |
| * | crystal | symbol | session-runtime | **Slot** - The immutable free/busy signal emitted when a session leaves the eligible set (budget exhaustion, pause, drain, stop), freeing scheduling capacity. |
| * | crystal | subsystem | session-runtime | **Scheduler** - The policy layer that reads a Table's Snapshot and selects the live session that should run next (StrictPriority or WeightedFair). |
| * | crystal | symbol | session-runtime | **session.State** - Live, mutable per-session control record: run-state, budget, priority, pace, and revision (an optimistic-concurrency guard). |
| * | crystal | subsystem | session-runtime | **sessionimage.Image** - Loaded, integrity-verified portable session archive: drive (session.json), recall manifest, ctxplan index, trajectory corpus, and image.json meta. |
| * | crystal | symbol | session-runtime | **SessionPlanner** - Persistent per-session context planner: a long-lived lossless store plus candidate index that ingests each turn's new messages incrementally. |
| * | crystal | concept | support-maturity | **support** - A capability is supported when fak has an implemented path that accepts the case without asserting how broadly it is exercised, whether every answer is right, how it compares to a peer, or whether it is production-mature. |
| * | crystal | metric | support-maturity | **coverage** - Coverage is the measured fraction of a declared or discovered universe that has rows, tests, witnesses, or other positioned evidence. |
| * | crystal | concept | support-maturity | **correctness** - Correctness is the property that the implementation's behavior matches its stated contract or oracle for the case being judged. |
| * | crystal | concept | support-maturity | **parity** - Parity is a same-workload comparison against a named peer, baseline, or oracle, reporting match, lead, or trailing behavior under the stated conditions. |
| * | crystal | concept | support-maturity | **maturity** - Maturity is the readiness level of a supported capability after considering implementation completeness, evidence breadth, correctness witnesses, parity results, guardrails, and operating posture. |
| * | crystal | symbol | witness-proof | **World-state witness** - An external reference (commit hash, blob digest, etag, lease epoch) a cache entry is admitted under, so the entry can be refuted when that external state changes. |
| * | crystal | symbol | witness-proof | **Claim** - A worker or agent's assertion that it completed an effect (shipped a phase, created a file, ran a test), awaiting corroboration against independent evidence. |
| * | crystal | symbol | witness-proof | **WitnessResolver** - The component that corroborates claims against independent evidence sources (git history, filesystem, HTTP APIs) and returns Confirmed, Refuted, or Abstain. |
| * | crystal | symbol | witness-proof | **Refutation** - The local decision that a witness is invalid (its cached state is stale or poisoned), triggering eviction of all entries admitted under it. |
| * | crystal | symbol | witness-proof | **Revocation** - The broadcast event published to the coherence bus when a witness is refuted, enabling cross-agent causal invalidation of cache entries. |
| o | defined | concept | attention | **Attention (softmax token-mixer)** - The default softmax scaled-dot-product self-attention token mixer (the be.Attention HAL op and m.attnSeq body) that mixes tokens via Q·K softmax over V. |
| o | defined | concept | attention | **self_attn (projection namespace)** - The self-attention sublayer's canonical tensor namespace (self_attn.{q,k,v,o}_proj plus q_norm/k_norm) that holds the projection weights of a softmax-attention block. |
| o | defined | symbol | attention | **attnOut (attention output buffer)** - The per-head context-vector buffer (nH*hd wide) that attention accumulates per position and then feeds into the o_proj output matmul. |
| o | defined | symbol | attention | **attnConcat (GLM-DSA output concat)** - GLM-DSA's per-head sparse-attention output, concatenated across heads (nH*vHead) and fed into o_proj in the DeepSeek-style sparse-attend path. |
| o | defined | symbol | attention | **attn_q (query projection)** - The GGUF `attn_q` query-projection weight (maps hidden state to the per-head query vectors of a self-attention layer). |
| o | defined | symbol | attention | **attn_k (key projection)** - The GGUF `attn_k` key-projection weight (maps hidden state to the per-KV-head key vectors of a self-attention layer). |
| o | defined | symbol | attention | **attn_k_b (MLA absorbed key up-proj)** - The GLM-DSA/MLA absorbed key up-projection weight `attn_k_b.weight` ([n_head, kv_lora, qk_nope], transposed at convert time) that lifts the compressed KV latent to per-head keys. |
| o | defined | symbol | attention | **attn_v_b (MLA value up-proj)** - The GLM-DSA/MLA value up-projection weight `attn_v_b.weight` ([n_head, v_head, kv_lora]) that lifts the compressed KV latent to per-head value vectors. |
| o | defined | symbol | attention | **attn_qkv (fused QKV projection)** - The single fused query+key+value projection tensor (self_attn.qkv_proj / GGUF attn_qkv) that some families (Phi, Qwen3.5 linear) ship and fak splits into q/k/v at load. |
| o | defined | symbol | attention | **attnScale (SDPA denominator)** - cfg.attnScale() — the per-head scaled-dot-product denominator (1/sqrt(HeadDim), or 1/sqrt(QueryPreAttnScalar) for Gemma) multiplied into the raw QK scores before softmax. |
| o | defined | config | attention | **AttnSoftcap (Gemma2 logit soft-cap)** - cfg.AttnSoftcap — the Gemma2 tanh soft-cap value applied in-place to attention logits (softcapInPlace) to bound them; 0 means off. |
| o | defined | config | attention | **AttentionBias (QKV bias flag)** - cfg.AttentionBias — the all-or-nothing flag (inferred from attn_{q,k,v}.bias tensors) that the q/k/v projections carry an additive learned bias (e.g. Qwen2). |
| o | defined | symbol | attention | **attentionNorms (attention norm bundle)** - m.attentionNorms(l) — the bundle of pre/post normalization weights (and biases) that wrap the attention sublayer for a layer's topology. |
| o | defined | symbol | attention | **post_attention_layernorm (MLP input norm)** - The HF-named `post_attention_layernorm.weight` — the RMSNorm applied to the residual BEFORE the MLP/SwiGLU sublayer (its name notwithstanding). |
| o | defined | symbol | attention | **attnSeq (dense attention body)** - m.attnSeq — the cacheless whole-sequence dense attention body (Q/K/V projection, RoPE, SDPA, o_proj) run over a panel of normalized inputs. |
| o | defined | symbol | attention | **attnBody (cached attention sublayer)** - The attnBody closure — the per-step attention sublayer over an already-normalized input that reads/writes the KV cache (kv.go, glm_dsa_session, minimax_m3_session) and returns the raw attention output. |
| o | defined | symbol | attention | **attnPrefillInto (prefill attention kernel)** - attnPrefillInto — the batched causal GQA attention kernel that computes a P-token prefill panel's attention and writes it into attnOut with optional sliding-window and soft-cap. |
| o | defined | symbol | attention | **attnDecodeBatch (batched decode attention)** - attnDecodeBatch — computes per-user causal attention for ONE batched decode step across B users, bit-identical to serial Step. |
| o | defined | config | attention | **attnGQAFuse (GQA fast-path flag)** - attnGQAFuse — the env-tunable flag that fuses a GQA group of 3 query heads sharing a KV head into one combined score-dot fast path. |
| o | defined | config | attention | **attnFdot3SIMD (3-wide score-dot SIMD)** - attnFdot3SIMD (with its attnFdot3SIMDMinBatch threshold) — the toggle enabling a 3-wide SIMD fused score dot-product (scoreDot3) for a GQA-3 group. |
| o | defined | config | attention | **attnSaxpy3SIMD thresholds** - attnSaxpy3SIMDMinBatch / attnSaxpy3SIMDMinPos — the batch- and position-count thresholds gating the 3-wide SIMD saxpy fast path that accumulates weighted value vectors. |
| o | defined | concept | attention | **linear attention (Gated-DeltaNet)** - The Gated-DeltaNet linear-attention token mixer that replaces softmax attention on hybrid layers (selected by c.isLinearAttnLayer); a recurrent linear scan instead of an O(n^2) softmax. |
| o | defined | symbol | attention | **linearAttnSeq (DeltaNet scan)** - m.linearAttnSeq — the concrete Gated-DeltaNet recurrent-scan implementation over a sequence (with linearAttnSeqBatched as the issue-#443 batched variant) that produces the linear-attention outputs. |
| o | defined | config | attention | **FullAttentionInterval (hybrid full layers)** - cfg.FullAttentionInterval — the hybrid Qwen3.5 schedule where every Nth decoder layer uses full (global) attention (LayerTypes 'full_attention') while the rest slide. |
| o | defined | config | attention | **sliding_attention (SWA layer type)** - The 'sliding_attention' LayerTypes value (derived in deriveLayerAttentionAxes) marking a layer that attends only within a bounded sliding window (SWA). |
| o | defined | symbol | attention | **isMiniMaxSparseAttn (MiniMax sparse path)** - c.isMiniMaxSparseAttn — the predicate selecting the MiniMax-M3 sparse-attention decoder path (m.layerMiniMax) for a layer. |
| o | defined | concept | attention | **RadixAttention (prefix cache)** - The SGLang-style RadixAttention prefix KV-cache (internal/radixkv) that walks a radix tree of past requests and reuses the longest cached prompt prefix. |
| o | defined | concept | attention | **PagedAttention (paged KV kernel)** - The vLLM-style PagedAttention / flash fused attention kernel concept that fak's Caps.FusedAttn can lower the whole Attention op to (paged KV blocks, online softmax). |
| o | defined | symbol | attention | **FusedAttn (capability flag)** - Caps.FusedAttn — the backend capability bit advertising it can lower the Attention op to ONE fused flash/online-softmax (paged) kernel (e.g. the CUDA backend, issue #486). |
| o | defined | symbol | attention | **ropeAttentionFactor (RoPE scaling)** - c.ropeAttentionFactor() — the RoPE long-context attention-scaling multiplier (YaRN/longrope), read from RopeParams.AttentionFactor, applied to the attention computation. |
| o | defined | symbol | attention | **softmaxAttentionScores (score softmax + sinks)** - m.softmaxAttentionScores — applies softmax to a head's attention scores, honoring per-head attention-sink logits (self_attn.sinks) when present. |
| o | defined | symbol | attention | **AttentionIndexReferences (index→KV dep)** - cachemeta.AttentionIndexReferences — the predicate reporting whether an attention_index cache entry depends on a given KV span (used by eviction/external-invalidation). |
| o | defined | symbol | attention | **SignalNoiseFromAttention (S/N split)** - ctxplan.SignalNoiseFromAttention — folds a Plan plus a WITNESSED per-span attention attribution into a signal-vs-noise mass split for a turn. |
| o | defined | symbol | attention | **OutcomeFromAttention (turn outcome)** - ctxplan.OutcomeFromAttention — produces a WITNESSED per-turn Outcome (classifies each resident span by its witnessed attention mass vs a hit threshold). |
| o | defined | subsystem | attention | **attnsnrsi (attention-S/N RSI command)** - The cmd/attnsnrsi command that closes the attention signal/noise RSI loop in SHADOW (#867), replaying a session's Forecast scored on attention attribution through rsiloop. |
| o | defined | symbol | attention | **SetAttnObserver (install observer)** - m.SetAttnObserver — installs (or clears with nil) the default-off attention-mass witness observer on the model, used to capture post-softmax weights without perturbing the forward pass. |
| o | defined | symbol | attention | **emitAttnRow (emit attention row)** - emitAttnRow — the hot-path helper that copies the post-softmax weights for one (layer, query position, head) window and hands the fresh slices to the installed observer. |
| o | defined | symbol | attention | **AttnObserver** - A callback that receives post-softmax attention distributions one (layer, query, head) row at a time for span attribution. |
| o | defined | symbol | attention | **Attended (span field)** - The per-turn witnessed post-softmax attention mass a span accumulated during one forward pass, reset at the turn boundary. |
| o | defined | symbol | attention | **AttendedMass (method)** - The total witnessed attention mass currently attributed across all live segments - the denominator that normalizes each span's attention into [0,1]. |
| o | defined | symbol | attention | **AttentionAccumulator** - Folds per-turn per-span witnessed attention masses into a recency-decayed EMA and an undecayed cumulative sum, keeping a bounded trajectory ring per span. |
| o | defined | symbol | attention | **SpanAttention** - A read-only snapshot of one span's accumulated attention: EMA (recency-decayed), Cumulative (undecayed), and the bounded Trajectory ring. |
| o | defined | symbol | attention | **TurnMass** - One entry in a span's attention trajectory: the witnessed mass it drew in a specific (1-based, session-global) turn number. |
| o | defined | subsystem | attention | **AttentionIndex** - Payload-free metadata for a dynamic-sparse-attention (DSA) index artifact, recording binding axes and dependency graph for content-dependent key selection. |
| o | defined | symbol | attention | **AttentionIndexRequest** - The set of axes a DSA index lookup must match for reuse, with strict causal and exactness requirements for prefix matching. |
| o | defined | symbol | attention | **linearAttnCache** - The cache for Gated-DeltaNet linear-attention layers: accumulated recurrent state and a short-conv window per layer, not per-token K/V. |
| o | defined | symbol | attention | **AttributeRow (method)** - Routes one post-softmax attention row onto the segment ledger, attributing each key position's weight to the live span whose cache range owns that position. |
| o | defined | symbol | attention | **glmDsaAttentionKStride (DSA key stride)** - The internal/model helper returning the GLM-DSA per-position key stride (NumHeads * (QKNopeHeadDim + QKRopeHeadDim)) used to size and index the K cache and paged GLM-DSA attention. |
| o | defined | symbol | attention | **glmDsaAttnSeqShared (replicated DSA attention body)** - The internal/model Model method running the GLM-DSA MLA + dynamic-sparse whole-sequence attention sublayer, replicated across expert-parallel ranks and optionally sharing a top-k selection across layers. |
| o | defined | config | attention | **num_attention_heads (HF head-count key)** - The HuggingFace config key `num_attention_heads` that benchcli/batchbench read into cfg.NumHeads (and from which HeadDim is derived as hidden_size/num_attention_heads when head_dim is absent). |
| o | defined | subsystem | cache | **vcachecal (M1 calibrate)** - internal/vcachecal is the vCache M1 observe-and-calibrate decision layer (#716): the warmth-belief estimator plus the offline probe harness that fits the T/M_min/r warmth law and reports false-warm/false-cold prediction error, off the hot path. |
| o | defined | subsystem | cache | **vcachescore (operator scorecard)** - internal/vcachescore is the vCache operator scorecard that composes the vcachecal/vcachestar/vcachegov proof leaves into the offline 2x-readiness gate and the hot-anchor index artifact. |
| o | defined | subsystem | cache | **vcachewarm (M3 warming)** - internal/vcachewarm is the vCache M3 dedicated-warming decision layer (#718): the Anthropic max_tokens:0-vs-decode-1 gates, byte-identical prefix guard, send-one-then-fan barrier, and wasted-warm accounting. |
| o | defined | subsystem | cache | **vcachestar (M2 star anchors)** - internal/vcachestar is the vCache M2 star-anchor decision layer (#717): canonicalizer-as-gate, wire-byte manifest keying, first-natural-request anchor warming, telemetry demotion, and uncached-first cost booking. |
| o | defined | subsystem | cache | **vcacheobserve (fak vcache observe)** - internal/vcacheobserve backs `fak vcache observe`, ingesting REAL provider-cache transcripts/telemetry into a per-session and cross-session hit-rate report. |
| o | defined | subsystem | cache | **cacheobs (observability tap)** - internal/cacheobs is the process-global observability tap that the in-kernel KV-prefix cache writes lifecycle events into for scraping. |
| o | defined | symbol | cache | **CacheHit (vdso event)** - CacheHit is a vDSO CacheEventKind value naming a tier-2 cache lifecycle HIT event (a cacheable lookup that an entry served), emitted to the cache-event sink. |
| o | defined | symbol | cache | **NOT_CACHED (miss reason)** - MissNotCached ("NOT_CACHED") is the vDSO miss-reason recorded when a lookup was cacheable but no tier-1/tier-3/tier-2 entry answered it. |
| o | defined | symbol | cache | **CachedTokens (provider field)** - CachedTokens is the raw provider-reported cache-read token count carried on cachemeta.ProviderCache and on the agent Usage prompt/input token details. |
| o | defined | symbol | cache | **CachedPromptTokens (normalized hit count)** - CachedPromptTokens is the agent Usage method (and AdjudicationSummary field) that normalizes Anthropic/OpenAI/Gemini prompt-cache hit counts into one cache-read prompt-token number. |
| o | defined | symbol | cache | **healthy_cache (reset reason)** - healthy_cache is the ResetReasonHealthy value of the resetScore SHADOW policy, the verdict that a turn's OBSERVED provider cache ratios look healthy enough to keep cutting rather than reset. |
| o | defined | symbol | cache | **MemoryKVCache (capacity class)** - compute.MemoryKVCache is the MemoryClass label "kv_cache" used by the capacity planner to bucket KV-cache allocations in the device memory plan. |
| o | defined | symbol | cache | **cachedInvFreq (RoPE memo)** - model.cachedInvFreq returns the memoized RoPE inverse-frequency table for a config/layer so the rotation base is computed once and reused. |
| o | defined | symbol | cache | **glmDsaKVCache (DSA session cache)** - model.glmDsaKVCache is the per-session KV cache struct for GLM-MoE-DSA sparse attention, holding pre-RoPE K, V, and the index span with reserve/evict/rerotate operations. |
| o | defined | symbol | cache | **glmDsaAttendCached (DSA attend)** - model.glmDsaAttendCached is the method that computes GLM-MoE-DSA sparse attention over the already-selected keys/values resident in a glmDsaKVCache (softmax(scale·q·k) then ΣwV). |
| o | defined | symbol | cache | **NewKVCache (dense allocator)** - model.NewKVCache allocates an empty dense full-attention KVCache (keeping pre-RoPE Kraw) for a model session. |
| o | defined | symbol | cache | **linearAttnCache (Qwen3.5 recurrent)** - model.linearAttnCache (constructed by newLinearAttnCache) is the per-session recurrent/conv state cache for Qwen3.5 hybrid linear-attention layers, held in the KVCache.linear field. |
| o | defined | symbol | cache | **growCaches (batch grow)** - model.growCaches grows a slice of *KVCache up to batch size B, allocating fresh per-row caches as needed for batched decode/prefill. |
| o | defined | symbol | cache | **uploadCache (device upload memo)** - compute.uploadCache (and its Metal twin metalUploadCache) shares one device/VRAM copy per distinct host buffer across all sessions so a weight tensor stages to the GPU once. |
| o | defined | symbol | cache | **FromProviderCache (constructor)** - cachemeta.FromProviderCache lowers a provider-reported ProviderCache observation into a cachemeta.Entry with provider residency and prompt-prefix media type. |
| o | defined | symbol | cache | **ProviderCacheVerdict** - cachemeta.ProviderCacheVerdict is the typed LookupVerdict answering "may this provider cache entry be served", returning cost_latency_only / non-serveable for provider residency. |
| o | defined | symbol | cache | **rawHasCacheControl (detector)** - agent.rawHasCacheControl is the predicate that tests whether a raw Anthropic JSON block (system, tool_result, or content) carries a cache_control breakpoint. |
| o | defined | symbol | cache | **CacheReadMultiplier (price coeff)** - gateway.CacheReadMultiplier (=0.1, mirrored in internal/resume) is the price of a cached-prefix READ relative to base input, used to value cache-read tokens in cost math. |
| o | defined | symbol | cache | **cache_rebate_tokens (debug field)** - cache_rebate_tokens is the OBSERVED per-turn field in the `fak serve --debug-stats` stderr line, the token-equivalent rebate computed as cacheRead·(1−CacheReadMultiplier). |
| o | defined | symbol | cache | **recordCompactionCacheRead** - gateway.recordCompactionCacheRead records the provider's cache_read_input_tokens on a compacted (streamed or buffered) turn so post-compaction billing truth is captured. |
| o | defined | symbol | cache | **PageCacheEntries (image enum)** - PageCacheEntries returns the cachemeta.Entry metadata for every page-table row of a context image (cdb.Image / contextq), without materializing the pages. |
| o | defined | symbol | cache | **emitCache (vdso emitter)** - vdso.emitCache builds a cachemeta entry from a tier-2 identity and dispatches it (outside the lock) to the installed cache-event sink. |
| o | defined | symbol | cache | **SetCacheEventSink** - vdso.SetCacheEventSink installs (or clears) the observer function that receives tier-2 cache lifecycle CacheEvents, wired by the gateway to fold them into fak_cache_*. |
| o | defined | symbol | cache | **vcacheProofFromCounters** - gateway.vcacheProofFromCounters prices the NET realized provider-cache economics over cumulative input/cached/creation counters into a vcachegov.TelemetrySavingsProof. |
| o | defined | symbol | cache | **VCacheTokenEquiv** - vcachegov.VCacheTokenEquiv is the token-equivalent cost of a vCache-anchored plan (write-multiplier·anchor + reuse reads + suffix), compared against the baseline to compute savings. |
| o | defined | config | cache | **EngineCache* serve knobs** - The EngineCache* serve flags (engine sglang|vllm, base-url, admin-key env, idle-timeout, require-exact-span) configure fak's reset of a self-hosted upstream serving-engine cache after a quarantined provider-bound tool turn. |
| o | defined | metric | cache | **fak_cache_* (stream metrics)** - fak_cache_* is the Prometheus metric family folding cachemeta.Entry events across ALL cache planes (the unified cross-plane events/bytes/breakdown counters rendered by the gateway's StreamMetrics). |
| o | defined | metric | cache | **fak_engine_cache_* (engine metrics)** - fak_engine_cache_* is the Prometheus metric family for live serving-engine KV cache events (events/hits/misses/faults/bytes/tokens moved across residency tiers), namespaced alongside fak_gateway_*/fak_kernel_*. |
| o | defined | subsystem | cache | **hwcachedemo (HW-aware proof cmd)** - cmd/hwcachedemo is a no-model, no-GPU command that proves fak's cache is hardware-aware by replaying an expensive hot-prefix span under hand-injected capacity pressure (demote-not-evict). |
| o | defined | doc-term | cache | **L3 disaggregated cache (study)** - l3cache is the docs/notes positioning study (epic #79) that fixes fak's relationship to an external, content-addressed remote-DRAM L3 KV-cache tier and maps fak's shipped semantic primitives onto the gaps that tier leaves open. |
| o | defined | concept | cache | **cache (overloaded umbrella term)** - "cache" is the bare umbrella word fak uses for several distinct reuse mechanisms at once: the in-kernel KV tensor store, the page-table virtualization (vCache), the provider prompt-cache fak only relays, the cachemeta metadata sidecar, and the cache-value P&L roll-up. |
| o | defined | subsystem | cache | **cachevalue (cache P&L rollup)** - The cachevalue stack (`fak cachevalue`, internal/cachevalueledger, internal/cachevaluereport, internal/cachevaluepost) is epic #1301's cache-effectiveness profit-and-loss roll-up: a durable append-only ledger of per-session reuse observations, folded into a by-week/by-session_type trend report, then posted as one Slack "cache-value" channel card configured by the FAK_CACHEVALUE_TOKEN/FAK_CACHEVALUE_CHANNEL resolution order. |
| o | defined | subsystem | cache | **vcacheTurns (observed provider-cache window)** - vcacheTurns is the gateway's bounded in-memory window of per-turn OBSERVED provider-cache counters (filled by metrics.observeVCacheTurn on every streamed passthrough turn, copied out via Server.VCacheTurnsSnapshot), which internal/vcachesnapshot persists to a JSONL file so a separate `fak vcache score`/observe process and the fak_vcache_* metric family can read the realized cache window a finished session saw. |
| o | defined | metric | cache | **provider-cache read/savings metrics** - ProviderCacheReadTokens (from the fak_gateway_inference_cached_prompt_tokens_total counter), ProviderCacheNetSavings, and the serving-engine PrefixCacheHitRate/cache_hit_rate ratios are the OBSERVED provider-and-engine cache numbers fak relays verbatim — the upstream provider's cache_read and the self-hosted engine's prefix hit rate, never numbers fak itself authored. |
| o | defined | doc-term | cache | **LMCache/MLCache (external KV-cache study refs)** - lmcache references the external LMCache KV-cache layer (GPU->DRAM->disk->Redis cross-query non-prefix reuse) that fak positions against and governs without moving KV bytes, while MLCACHE1..MLCACHE6 are the plan/phase rung labels of fak's own docs/serving/multilevel-default-cache-epic.md multilevel-default-cache epic that lands the DRAM/disk/CXL pressure-aware placement those external systems motivate. |
| o | defined | symbol | cache | **CacheEventRecorder (engine event seam)** - engine.CacheEventRecorder (built by NewCacheEventRecorder) is the live serving-engine cache-event seam: the routing/offload path calls Record for each KV residency transition, which normalizes it into the shared cachemeta entry stream, derives the typed verdict, folds fak_engine_cache_* metrics, and returns a CacheEventResult. |
| o | defined | symbol | cache | **KVCacheToPaged (paged materialize)** - model.KVCacheToPaged snapshots a dense softmax KVCache into a fresh 3-plane paged sequence (the P/D-disaggregation and preemption swap path), and PagedKV.ToKVCache is its inverse that reconstructs a live contiguous *KVCache from a paged sequence's K/V pages. |
| o | defined | symbol | cache | **CachePricing (USD cost model)** - gateway.CachePricing is a model's base per-million-token input/output price whose CostUSD prices one turn's CacheUsage (uncached input at 1.0x, cache read at 0.1x, the provider's cache-create write at its TTL multiplier, output at the output rate), where CacheUsage is the four-axis token accounting (input/cacheRead/cacheCreate/output) the Anthropic usage block reports. |
| o | defined | subsystem | cache | **cachewitness (provenance evidence fold)** - internal/cachewitness reads a live fak gateway's /metrics and folds the cache numbers into ONE provenance-labeled Record, splitting the WITNESSED in-kernel KV-prefix reuse fak controls from the OBSERVED provider cache_read it only relays, so a reader can never mistake fak's own reuse for the provider's. |
| o | defined | symbol | cache | **CompactReasonCachedSpan (compaction guard)** - agent.CompactReasonCachedSpan ("cached_span") is the conservative compaction outcome reason returned when a candidate history drop would delete cache_control-marked content, so the agent refuses to shed a span the provider prompt-cache is keyed on. |
| o | defined | concept | cache | **cacheability (CapRef resolution)** - In contextq, cacheability is the property that the same CapRef must resolve to the same Capability across a body, so a capability reference is stable enough to be reused/cached rather than re-resolved. |
| o | defined | concept | cache | **CacheOptimization (worktype class)** - worktype.CacheOptimization ("cache-optimization") is the ongoing agent-memory-and-reuse program work class the epic classifier assigns to cache epics (e.g. #1301/#1351/#1217), labeling them as a continuous program rather than a discrete one-off. |
| o | defined | config | cache | **DefaultCacheSize (LRU capacity tunable)** - DefaultCacheSize is the baseline LRU capacity integer literal the RSI loop tunes (internal/rsiloop and internal/vdso each declare one): the tier-2/vDSO cache slot count kpiprobe reports a hit-rate for and the worktree harness rewrites to measure a candidate. |
| o | defined | config | cache | **learningdebt --cache path (seen-cache flag)** - cachePath is the `fak learningdebt --cache` flag value, the path to the learning-debt dispatch seen-cache JSON (default <workspace>/.fak/learning-debt-dispatch/seen.json) that records already-dispatched items. |
| o | defined | config | cache | **DefaultProviderCacheTTL (idle expiry)** - compactcohere.DefaultProviderCacheTTL (5 minutes) is the idle-expiry the harness-coherence coordinator assumes for the provider's prompt cache, used to decide when a provider cache entry has aged out between turns. |
| o | defined | symbol | cache | **NewViewCache (contextq ViewCache ctor)** - contextq.NewViewCache returns an empty, concurrency-safe ViewCache that backs a context request's resolved-view reuse across recall/skill-memory/workflow-memory paths. |
| o | defined | symbol | cache | **PlaceAnthropicCacheBreakpoint (breakpoint placer)** - agent.PlaceAnthropicCacheBreakpoint rewrites a raw Anthropic request to place the cache_control breakpoint marker on the prompt prefix so the provider caches that span, returning a BreakpointOutcome describing what it did. |
| o | defined | symbol | cache | **vBlock** - The unit of cacheable work in vCache: a cachemeta entry whose identity carries every axis that must match for provider reuse (content digest, model, tokenizer, endpoints, position in prefix DAG). |
| o | defined | symbol | cache | **KVLayout** - The interface abstracting the per-position bytes a given attention variant caches and how to reconstruct per-head K/V from those bytes (standard vs MLA). |
| o | defined | symbol | cache | **MLAConfig** - The low-rank MLA projection geometry (DeepSeek V2/V3): latent width, RoPE dim, and down/up projection matrices for compressing the K/V cache. |
| o | defined | symbol | context-ctx | **context.Context plumbing helpers (stdlib)** - exec.CommandContext is the Go standard-library constructor that threads a cancellable context.Context into a spawned subprocess, one of the stdlib context-plumbing helpers fak uses to carry deadlines and cancellation through calls. |
| o | defined | symbol | context-ctx | **BaseContextPlan (syspromptmmu)** - syspromptmmu.BaseContextPlan returns the embedded-PromptSegment projection of the base system context (TierSpine then the TierPolicy floor) as a byte-identical, no-wire-mutation plan. |
| o | defined | symbol | context-ctx | **AutoSizeContextPlan (compute sizer)** - compute.AutoSizeContextPlan derives the largest context-token count that fits available memory and returns the per-context KV/scratch MemoryPlan for it, reading geometry from a compute.ContextSizeConfig (KV/scratch configs plus the model's declared MaxContext). |
| o | defined | symbol | context-ctx | **putCtx (modelengine pipeline)** - putCtx is the context.Context carried through the modelengine PipelineEngine.run / lifecycle adapter for one put (decode) request, scoping cancellation of that pipeline step. |
| o | defined | symbol | context-ctx | **ctxParts (Slack post builder)** - ctxParts is the local string slice that the Slack-post render functions (blockerpost, cachevaluepost, milestonepost, marketing) accumulate into a single Slack context block's text (ref, posted-by, etc.). |
| o | defined | symbol | context-ctx | **AppendContext (slackmeta block)** - slackmeta.AppendContext appends a Slack context block carrying the signal-to-noise line to a message's blocks, unless an existing block already includes one. |
| o | defined | subsystem | context-ctx | **dos_recall (MCP recall-check tool)** - dos_recall is the DOS MCP tool (named across loopmap/rehydrate/accounts comments as the kernel-side equivalent) that re-verifies a recalled memory against the tree at read time before it is trusted, since a memory reflects only what was true when written. |
| o | defined | symbol | context-ctx | **maxCtx (ctxdemo peak length)** - maxCtx is the local running maximum the ctxdemo / longctxbench / sessionbench tools track as they scan scenarios for the largest context length any scenario reaches. |
| o | defined | symbol | context-ctx | **tombstoned_by_context_control (page-in refusal reason)** - tombstoned_by_context_control is the ctxplan/contextq/memq refusal reason string returned when a span is denied page-in because it was suppressed by a context-control tombstone (recall.ErrTombstoned). |
| o | defined | symbol | context-ctx | **BUDGET_CONTEXT_EXHAUSTED (session reset reason)** - BUDGET_CONTEXT_EXHAUSTED is the session/gateway reset reason constant (session.ReasonBudgetContext, gateway.sessionReasonBudgetContext) emitted when ContextTokensLeft hits zero, returning a managed reset directive. |
| o | defined | metric | context-ctx | **CompactionBudget (history-rewrite threshold)** - CompactionBudget is the gateway exit-summary field (Config.CompactHistoryBudget) holding the resident-token threshold the history rewrite fires past (0 means the compaction lever is OFF and the body is forwarded byte-for-byte). |
| o | defined | symbol | context-ctx | **ContextBudget (TUI session field)** - ContextBudget is the cmd/fak TUI report field (json context_budget) carrying a session's configured context-token budget for display in the overview/sessions panes. |
| o | defined | symbol | context-ctx | **CtxWith / CtxWithout (tokendemo counters)** - CtxWith and CtxWithout are the cmd/tokendemo per-scenario counters of the model tokens added to context with fak's gate engaged (a refused/cached path) versus without it (the tool re-runs and its full result lands), used to show fak only saves on a refused bad call or a re-read. |
| o | defined | symbol | context-ctx | **SkillContextRecord (contextq descriptor)** - contextq.SkillContextRecord is the procedural-memory descriptor for one skill invocation, naming the producer and view-cache producer for that skill's context entry. |
| o | defined | doc-term | context-ctx | **ContextBench (academic context-retrieval benchmark)** - ContextBench is an external academic code-agent context-retrieval benchmark (separate repo, Nanjing University + UCL research) named in docs/benchmarking/README.md as a context-retrieval comparison surface. |
| o | defined | doc-term | context-ctx | **ContextCite (attribution research method)** - ContextCite is an external 2024 research method (Cohen-Wang et al., "ContextCite: Attributing Model Generation to Context") cited in fak's span-credit research notes as prior art for attributing generation to context spans. |
| o | defined | symbol | context-ctx | **derived ContextView (cachemeta MemoryView)** - The derived ContextView is the cachemeta materialization view (exercised by TestFromMemoryViewDescribesDerivedContextView) that FromContextPage / FromMemoryView describes for a ContextPage span when deciding cache serveability. |
| o | defined | subsystem | context-ctx | **ctxtape (portable context-tape renderer)** - ctxtape is the portable context-tape renderer (shipped in v0.33.0) that renders any trajectory, RSI, or education run as a portable context tape. |
| o | defined | symbol | context-ctx | **ContextTokensLeft (session budget)** - ContextTokensLeft is the session.Budget field holding the remaining prompt/context-token budget a served session has before context-budget exhaustion triggers a reset directive. |
| o | defined | symbol | context-ctx | **ContextTokens (session usage)** - ContextTokens is the per-turn usage field on gateway.SessionUsage / session.Usage carrying the prompt/context-window token count to debit from the session budget. |
| o | defined | symbol | context-ctx | **RequestContextChange (recall)** - RequestContextChange is the recall.Session method that applies a safe, negative-only context mutation — recording a tombstone that suppresses one page from future model-visible recall without deleting bytes. |
| o | defined | symbol | context-ctx | **ContextActionTombstone** - ContextActionTombstone is the recall.ContextAction constant ("tombstone_page") naming the one shipped, deliberately negative-only context mutation that narrows what may enter future context. |
| o | defined | subsystem | context-ctx | **ctxplanbench (planner bench cmd)** - ctxplanbench is the cmd/ctxplanbench benchmark that measures the ctxplan planned VIEW (compaction count, recovered tokens) over real Claude Code session transcripts. |
| o | defined | symbol | context-ctx | **ContextChanges (recall ledger)** - ContextChanges is the recall.Session accessor (and Manifest field) returning the applied, durable context-control ledger — the list of tombstone rows recorded against the core image. |
| o | defined | metric | context-ctx | **ContextPollutionRate (bench KPI)** - ContextPollutionRate is the bench KPI computed as the rate of ctxmmu quarantines per tool call in the gates-on run. |
| o | defined | subsystem | context-ctx | **ctxdemo (multi-agent demo cmd)** - ctxdemo is the cmd/ctxdemo live on-box demonstrator that runs a catalog of multi-agent shapes to show fak's prefill/KV-reuse value, reporting per-scenario max context and fak-vs-tuned token work. |
| o | defined | config | context-ctx | **CtxViewBudget (gateway knob)** - CtxViewBudget is the gateway.Config field that, when > 0, wires the ctxplan context planner into the live serve/guard loop and materializes each turn's history as an O(1) planned view under this resident-token budget. |
| o | defined | symbol | context-ctx | **ProveRecallInput (vcachechain)** - ProveRecallInput is the vcachechain struct holding the caller-supplied calibration (prefix tokens, unit tokens, read-multiplier, siblings) that the recall economics proof is run over. |
| o | defined | cli-verb | context-ctx | **cmdRecall (fak recall verb)** - cmdRecall is the cmd/fak handler for `fak recall` — the offline session-recall demo that writes a session through the gate, reloads it in a fresh Session, and demonstrates the rung-0/rung-4 poison-refusal guarantees. |
| o | defined | metric | context-ctx | **CompactionFired (gateway metric)** - CompactionFired is the gateway metrics counter of compaction attempts that fired — the turn body was rewritten with the protected prefix shipped byte-identical. |
| o | defined | symbol | context-ctx | **contextBudgetAxis (TUI formatter)** - contextBudgetAxis is the cmd/fak formatter that renders a context-token budget value as a short axis cell ("inf" for <0, "off" for 0, else the number) for ps/overview/session rows. |
| o | defined | config | context-ctx | **context-budget-tokens (guard flag)** - contextBudgetTokens is the `fak guard --context-budget-tokens` flag that seeds the guard session with a prompt/context-token budget so exhaustion returns a reset directive with a continuation id. |
| o | defined | symbol | context-ctx | **ContextTokensCap (budget denominator)** - ContextTokensCap is the session.Budget field recording the configured context-budget size — the denominator the pre-exhaustion warning measures consumed-share against (0 means no context budget). |
| o | defined | symbol | context-ctx | **ContextWindowTokens (usage method)** - ContextWindowTokens is the agent.Usage method that computes the prompt/context size to count against a long-session budget, adding Anthropic cache_read/cache_creation tokens back onto input_tokens. |
| o | defined | subsystem | context-ctx | **ctxbench (security-gate corpus cmd)** - ctxbench is the cmd/ctxbench tool that runs fak's security gates over a corpus of tool calls and reports the injection/quarantine outcomes. |
| o | defined | symbol | context-ctx | **handleFakContextChange (gateway route)** - handleFakContextChange is the gateway HTTP handler for POST /v1/fak/context/change that records a requester-initiated tombstone against a persisted recall core image. |
| o | defined | symbol | context-ctx | **freshContextTokens (guard reseed)** - freshContextTokens is the cmd/fak guard budget-restarter field holding the fresh context-token budget to reseed onto a continuation trace after a budget-triggered managed reset. |
| o | defined | symbol | context-ctx | **InjectionInContext (agent harness)** - InjectionInContext is the agent loop-result boolean recording that a tool result carrying a prompt injection actually reached the model in the context. |
| o | defined | subsystem | context-ctx | **longctxbench (long-context floor cmd)** - longctxbench is the cmd/longctxbench tool that renders the exact, contention-free token-work floor for ultra-long-context / agent-city regimes across a prefix/turns/agents ladder. |
| o | defined | symbol | context-ctx | **MaxContext (swebench geometry)** - MaxContext is the swebench.Geometry method giving the largest context length a workload geometry reaches, computed as Prefix + Turns*(Decode+Result). |
| o | defined | symbol | context-ctx | **NewRecallBackend (memq)** - NewRecallBackend is the memq constructor that builds the negative-only recall backend — a tombstone store that drives suppression through recall.RequestContextChange persisted to a directory. |
| o | defined | symbol | context-ctx | **PlanRecall (vcachechain)** - PlanRecall is the vcachechain M4 entry point that, given a prefix DAG, a recall request, and an enable flag, returns the recall verdict plus the economics and cold-tail replay schedule. |
| o | defined | config | context-ctx | **RopeOrigContext (model config)** - RopeOrigContext is the model.Config field (rope_scaling_original_max_position_embeddings) holding the original pre-scaling max position / context length used as the reference when applying RoPE scaling. |
| o | defined | subsystem | context-ctx | **ctxresidency (residency query package)** - ctxresidency is the internal package providing the context-residency query: a pure, witnessable READ that composes kvmmu, ctxmmu, and cachemeta to classify each span resident/evictable/held with its evict blast radius. |
| o | defined | subsystem | context-ctx | **ctxplandemo (planner demo cmd)** - ctxplandemo is the cmd/ctxplandemo runnable demonstrator for the context PLANNER, treating a transcript as a plannable store and showing the planned view it materializes. |
| o | defined | symbol | context-ctx | **SpeculationContext** - Transient state for brainstorm epochs: (Speculative, Epoch, ParentEpoch) marking provisional effects produced under speculation. |
| o | defined | symbol | context-ctx | **ContextChangeRequest** - Negative-only context mutation request: one persisted recall-page tombstone with reason, requestor, and witness. |
| o | defined | symbol | context-ctx | **RecallProof** - Self-describing proof of a recall cost calculation: shows the gate's work (PrefixTokens, UnitTokens, ReadMult, siblings, cost breakdown). |
| o | defined | symbol | context-ctx | **ProveRecall** - Pure function that runs the recall cost gate over its inputs and returns a RecallProof showing the gate's work. |
| o | defined | concept | context-ctx | **CtxView** - A planned, budgeted view of context the CtxViewPlanner selects for one turn within a token budget. |
| o | defined | concept | context-ctx | **context window** - The model's hard token budget that the planner allocates resident spans within. |
| o | defined | symbol | context-ctx | **ContextChange (apply)** - The applied negative mutation: tombstones a recall page through the trust gate per a ContextChangeRequest. |
| o | defined | symbol | decision | **DecisionJournal (modelroute)** - modelroute.DecisionJournal is the append-only record of model-routing decisions; each entry is a DecisionRecord (rule, strategy, members, scout calls, overhead, digest) built by RecordDecision after a route is chosen, exported to metrics and audit. |
| o | defined | symbol | decision | **RouteDecision (guardroute)** - guardroute.RouteDecision is the pure verdict over a guard session's RSI fold and worst bucket — whether to route a finding to a queue row or a GitHub issue, at what severity, with a stable cause-key — while cmd/fak guardLocalModelDecision separately decides whether `fak guard` runs a local in-kernel model versus an upstream proxy. |
| o | defined | symbol | decision | **EditDecision (prompt-mutation schema)** - EditDecision (docs/standards system-prompt-mutation schema) is the reviewable admit|refuse|demote verdict a check yields for a PromptEdit, paired in the schema with OverlayDecision, the reviewable fault|hit|refuse verdict that resolving an OverlayQuery yields. |
| o | defined | symbol | decision | **PlacementDecision (cachemeta)** - A cachemeta planner verdict struct (Action, FromTier, ToTier, Directive, EstMoveBytes, Reason) returned by PlanPlacement that recommends whether a KV span should be kept, promoted, demoted, spilled, compress-demoted, or evicted across residency tiers without ever moving bytes itself. |
| o | defined | symbol | decision | **AppendDecision (witness recorder)** - A witness.Recorder method that appends one JSON-encoded Decision as an append-only git note on refs/notes/fak/decisions, anchored to the concerned commit SHA (or the empty-tree sentinel for a pre-commit refusal), never touching branches or force-pushing. |
| o | defined | symbol | decision | **GovernorDecision (vcachegov)** - A vcachegov string-typed steady-state verdict (ride_natural, heartbeat_pin, lazy_rebuild, evict, no_cache, explicit_cache) the Governor returns for one prompt prefix, deciding how to keep a provider prompt-cache prefix warm based on arrival rate versus TTL and policy law. |
| o | defined | symbol | decision | **RedundantDecisionEvent (abi de-double)** - An abi predicate that reports whether an Event is a SECOND emission of a decision another event already carries (a Deny's paired EvDecide, or a require-witness EvDecide on a submitted call), so a decision-stream folder counts each logical decision exactly once. |
| o | defined | symbol | decision | **ResetDecision (gateway reset)** - The advisory verdict struct (ShouldReset bool, Score 0..1, Reason) returned by gateway ResetPolicy.ResetScore recommending whether a session's KV cache should be RESET to a fresh context instead of CUT by dropping middle turns, logged in shadow mode and acted on by nothing yet. |
| o | defined | subsystem | decision | **decisions ref (witness journal)** - refs/notes/fak/decisions, the dedicated append-only git-notes ref (constant decisionsRef) the witness Recorder writes adjudication Decisions to, one JSON line per note anchored to the concerned commit, forming the durable decision journal. |
| o | defined | symbol | evict | **KVEvictionAttestation (cachemeta receipt)** - cachemeta.KVEvictionAttestation is the payload-free receipt both eviction tracks produce after a governed K/V eviction — carrying the target entry id, the enforcement scope (KVEvictionScopeExactSpan vs whole-prefix), a degradation bit, and the governance descriptor — minted by the referee's AttestEviction, with EvictBlastRadius the read-only projection of how many positions and dependents one eviction touches. |
| o | defined | symbol | evict | **PagedKV.Evict (paged exact-span removal)** - PagedKV.Evict (internal/model/paged_evict.go) removes a contiguous logical span from a paged/block KV sequence and re-derives each shifted survivor's K in one rotation from its pre-RoPE Kraw plane so the result is bit-for-bit what a sequence that never saw the span would hold, rebuilding into fresh private blocks (copy-on-write); the agent's InKernelPlanner.EvictKVSpan drives the contiguous twin to quarantine a poisoned per-message span. |
| o | defined | symbol | evict | **KVCache.TryEvict (fallible exact-span evict)** - model.KVCache.TryEvict performs a middle-span eviction that surfaces a no-go as a typed RecurrentEvictUnsupportedError (returned for hybrid Gated-DeltaNet caches whose accumulated recurrent state makes mid-span eviction formally unsupported) and leaves the cache unchanged, rather than panicking. |
| o | defined | symbol | evict | **EvictUnderBudget (budget-gated evictor)** - EvictUnderBudget (kvmmu Context and contextq CapabilityLedger) applies coldest-first eviction ONLY when live residency exceeds the configured budget, freeing positions or capabilities until the held set is back under budget, and is a no-op otherwise. |
| o | defined | symbol | evict | **StateEvictable (ctxresidency state)** - ctxresidency.StateEvictable is the residency-state constant ("evictable") marking a span whose K/V is in cache but parented by no live cachemeta entry — a clean candidate the evictor may drop without breaking a dependent. |
| o | defined | symbol | evict | **CAP_EVICT (journal event kind)** - internal/journal CAP_EVICT is the durable journal event-kind constant recording a capability-eviction lifecycle event in the append-only audit trail. |
| o | defined | symbol | evict | **EvictedCount (deletion-cert field)** - EvictedCount (cmd/deletioncert) is the self-reported number-of-positions-removed field stamped into the signed KV deletion certificate, explicitly fenced as a self-report whose real proof is the max|delta|=0 parity, not the count. |
| o | defined | symbol | evict | **EvictColdest (kvmmu)** - EvictColdest (internal/kvmmu/attention.go) drops the coldest-by-attention-EMA UNPINNED KV spans from a Context until at least targetPositions cache positions are freed (or no unpinned live spans remain), excluding pinned (e.g. system) spans from the candidate set entirely. |
| o | defined | symbol | evict | **ActionEvict (cachemeta)** - ActionEvict (internal/cachemeta/placement.go) is the PlacementAction constant "evict" — the placement planner's verdict to drop a cache entry entirely and recompute it on demand (FromTier -> TierRecompute), the last resort taken after demote/spill/compress_demote are exhausted or refused. |
| o | defined | symbol | evict | **evictExcessLocked (bounded-FIFO)** - evictExcessLocked (internal/ctxmmu/mmu.go, and the parallel guards in preflight/normgate/secretgate) drops the OLDEST held entries FIFO until the held set is back within its maxHeld bound, releasing each dropped entry's resource (CAS pin / handle) and bumping an evicted counter — a memory bound on a quarantine / negative-cache, called under the owner's lock. |
| o | defined | symbol | evict | **EvictKV (speculative rollback)** - EvictKV (internal/polymodel/polymodel.go, a SpecResult/TreeResult field) is the count of speculative KV positions to ROLL BACK after a speculative-decode verify pass — the drafted-but-rejected positions (== K - Accepted) fed to model.KVCache.Evict so the cache is bit-exact to never having drafted them. |
| o | defined | symbol | evict | **EvictNode (radixkv policy)** - EvictNode (internal/radixkv/radixkv.go) is POLICY eviction in the radix prefix cache: it removes a node and its ENTIRE subtree regardless of LRU recency or lease state, returning tokens freed — the seam a quarantine verdict drives to purge a poisoned shared prefix. |
| o | defined | metric | evict | **Evictions (radixkv LRU counter)** - Evictions (internal/radixkv/radixkv.go Stats, surfaced via the agent KVMemoryStats) counts the LRU leaf evictions the radix prefix cache performed under its token budget — opportunistic drops of the least-recently-used cached prefix when LRUTokens exceeds the configured MaxTokens. |
| o | defined | symbol | evict | **Evicted (revocation count)** - evicted is the return count of internal/vdso VDSO.Revoke (and the Revocation/RevokeResponse.Evicted field in gateway/coherence.go) — how many pooled cache entries were causally dropped when an external trust witness was refuted, every entry admitted under that witness invalidated MESI-invalidate style. |
| o | defined | symbol | gateway-engine | **EngineCallsAvoided (tokendemo proof)** - The cmd/tokendemo served-read proof field (RawEngineCalls - FakEngineCalls) counting how many raw engine dispatches the kernel collapsed, alongside RawEngineCalls (the calls a stateless baseline would make), FakEngineCalls (the calls that actually ran the engine), EngineRanFak (the per-row flag that a call hit the real fak engine rather than the vDSO), and EngineDelayMs (the synthetic per-engine-call latency knob the timing proof injects). |
| o | defined | symbol | gateway-engine | **inkernelchat (chat-serving wiring)** - The servewiring/serve-config seam (`inkernelchat`) by which a gateway started with --gguf/--tokenizer and no --base-url serves /v1/chat/completions and /v1/messages from the in-kernel model, built by loadServeInKernelModel (which also returns the InKernelQ4K resident-Q4_K flag) and run through NewInKernelPlanner's greedy decode. |
| o | defined | symbol | gateway-engine | **EvVDSOHit (vDSO event)** - The abi.Event kind emitted when a tool call is served locally by the vDSO fast path (no adjudication, By="vdso"), counted distinctly by observers; it names the same fast-path serve that VDSOOffNet ablates away, that FromVDSOKey describes as a tier-2 tool-result cache entry, and that VDSOProxyFill warms from admitted inbound tool_result blocks. |
| o | defined | symbol | gateway-engine | **glmDsaMatKernel (GLM-DSA compute selector)** - The internal/model Session method (moe_offload.go) that selects which matKernel the GLM-DSA forward runs its dense GEMMs through in one place, where the underlying compute knobs include FAK_QKERNEL (the SIMD quant-GEMM tier pin), LinearConvKernelDim (the Gated-DeltaNet short-conv kernel width), the CUDA pure kernels in cuda_kernels.cu, and the worktype KernelOptimization throughput program. |
| o | defined | metric | gateway-engine | **fak_gateway_operation_duration_seconds** - The Prometheus histogram of gateway operation latency labeled by operation type (adjudicate, syscall, admit), verdict, and deciding adjudicator, whose bucket cutoffs come from the package-level gatewayLatencyBuckets slice. |
| o | defined | metric | gateway-engine | **fak_gateway_kv_prefix_* (KV-prefix reuse family)** - The gateway's witnessed KV-prefix reuse metric family (fak_gateway_kv_prefix_turns_total, _prompt_tokens_total, _reuse_ratio, _turns_by_regime_total) that measures realized RadixAttention prompt-prefix reuse per in-kernel turn, with fak_gateway_kv_prefix_reused_tokens_total as the specific counter of prefix tokens the kernel did NOT re-prefill. |
| o | defined | symbol | gateway-engine | **routeEngine (per-call engine router)** - The gateway Server method that consults the optional per-call routing policy on every buildCall and returns the engine id to stamp onto abi.ToolCall.Engine (returning "" for the kernel-default path or an unset ensemble). |
| o | defined | symbol | gateway-engine | **EngineIDs (registry listing)** - abi.EngineIDs() returns the id-sorted list of registered inference-engine drivers from the engine registry snapshot, used for forensics, gateway validation, and engine selection. |
| o | defined | symbol | gateway-engine | **SGLangEngineID (sglang adapter)** - The internal/engine SGLang adapter registered under the engine id "sglang" (SGLangEngineID), a lifecycle-capable EngineDriver in the dispatchable registry; the external vLLM/SGLang serve harness is configured separately through the ENGINE_ARGS env var passed to the serve script. |
| o | defined | symbol | gateway-engine | **PureFakKernel (GCP plan test)** - The cmd/fak test TestClaudeGLMGCPA100PlanWiresPureFakKernel, asserting the Claude-GLM-on-GCP-datacenter GPU plan wires the pure in-kernel fak model path (the DRY cuda-binary subcommand) rather than an external upstream. |
| o | defined | symbol | gateway-engine | **normalizeTUIAgentGatewayURL (URL normalizer)** - The cmd/fak helper that validates and normalizes the gateway base URL a TUI agent / info command is pointed at, returning the canonical base used to build debug and agent requests. |
| o | defined | symbol | gateway-engine | **HTTPEngine (deleted OpenAI seam)** - The degenerate, never-wired engine.HTTPEngine OpenAI-client seam that was DELETED in v0.7.1 (with an architest invariant keeping the OpenAI client singular), leaving agent.HTTPPlanner as the one OpenAI client. |
| o | defined | symbol | gateway-engine | **matKernel (compute)** - The internal/model interface that selects which arithmetic a single decode block's weight matmuls run through — prep turns a normed activation into the kernel's operand form once, and mul applies a named weight to it — so the f32 and Q8 decode blocks share one block skeleton. |
| o | defined | symbol | gateway-engine | **f32Kernel (compute)** - The matKernel that runs a decode block fully in f32 — prep is the identity and every matmul routes through parMatRows (the in-order row-parallel GEMV), preserving the bit-exact reduction order. |
| o | defined | symbol | gateway-engine | **q8Kernel (compute)** - The matKernel that runs a decode block in Q8_0, quantizing the activation once per prep into a q8Vec and multiplying it against the prebuilt Q8_0 weight via qMatRows. |
| o | defined | symbol | gateway-engine | **q4Kernel (compute)** - The matKernel that runs a decode block in int4 (Q4): prep is the identity and mul applies the int4-packed weight via the q4 GEMV. |
| o | defined | symbol | gateway-engine | **residentKernel (compute)** - The cacheless Forward matKernel that prefers the exact f32 tensor when present and otherwise reads the quant-on-load Q8_0 resident copy via residentMatRows, keeping ordinary Forward bit-identical. |
| o | defined | symbol | gateway-engine | **backendKernel (compute)** - The matKernel that routes the GLM-MoE-DSA forward's dense GEMMs through a compute.Backend (the GPU pure kernels) instead of host residentMatRows, uploading weight+activation, running be.MatMul, and reading the result back. |
| o | defined | symbol | gateway-engine | **splitKernel (compute)** - A thin matKernel that dispatches each named matmul per-weight to a host sub-kernel or a device sub-kernel by a predicate, implementing the --n-cpu-moe split (offloaded experts on host RAM, dense projections/router/attention on GPU). |
| o | defined | symbol | gateway-engine | **dsaIndexKernel (compute)** - The optional device-path interface for GLM-MoE-DSA's learned-indexer score + top-k selection (indexSelect), taken only when the backendKernel's compute.Backend advertises DSAIndexBackend; otherwise the host f64 score/top-k loop runs. |
| o | defined | symbol | gateway-engine | **dsaSparseKernel (compute)** - The optional device-path interface for GLM-MoE-DSA's sparse-attention compute (sparseAttend: per-head softmax(scale·q·k)·V over the host-selected keys), taken only when the backend advertises DSASparseBackend. |
| o | defined | symbol | gateway-engine | **KernelCounters (turnbench)** - The turnbench replay harness's snapshot struct of the coordinator kernel's call-path tallies (submits, vDSO hits, engine calls, denies, transforms) gathered over a replayed trace. |
| o | defined | symbol | gateway-engine | **FromKernel (toollint)** - toollint.FromKernel builds tool-lint facts (fast-path tables + preflight schemas) from the process-global kernel registries (vdso.Default and the engine registries) for the registry-only lint view. |
| o | defined | symbol | gateway-engine | **inkernel (engine id)** - The id under which internal/modelengine registers internal/model as an abi.EngineDriver, so `--engine inkernel` (or one blank-import) dispatches a tool call to the model fused into the fak process via a real Prefill+Step decode. |
| o | defined | symbol | gateway-engine | **InKernelPlanner** - The agent.Planner backed by the in-kernel model: one Complete runs a greedy Prefill+Step decode over a kernel-owned KV cache using the loaded model + tokenizer. |
| o | defined | symbol | gateway-engine | **InKernelCapacityError** - The request-time error the InKernelPlanner returns when a request's prompt + max-new tokens would exceed device capacity, refusing before any decode allocation. |
| o | defined | symbol | gateway-engine | **InKernelOOMError** - The agent-level, recovered form of an in-kernel device-allocation OOM during decode, carrying the failed byte count, memory class, and site. |
| o | defined | symbol | gateway-engine | **inKernelOOMObservation** - The gateway-side function that classifies an error as a recovered in-kernel OOM and extracts its (class, bytes, site) so the metrics layer can count it. |
| o | defined | symbol | gateway-engine | **InKernelOOMRetryStats** - The struct reporting idle-pool trim retries attempted after in-kernel device OOMs, bucketed by backend, memory class, and outcome, surfaced through the InKernelOOMRetryReporter interface. |
| o | defined | symbol | gateway-engine | **InKernelMemoryPressureTrimStats** - The struct reporting PROACTIVE idle-pool trims the in-kernel planner takes under memory pressure, in bounded-label rows per backend and memory class, surfaced via InKernelMemoryPressureTrimReporter. |
| o | defined | config | gateway-engine | **FAK_INKERNEL_KVMMU** - The environment-variable gate that opts the gateway into the in-kernel KV-MMU slot-reclaim bridge (a real SlotFreed -> KV eviction); default-off, where the bridge is an inert no-op. |
| o | defined | config | gateway-engine | **FAK_XENGINE_KV** - The environment-variable gate that opts an Arena into becoming the cross-engine zero-copy KV co-residence RegionBackend (the xenginekv package, #448); unset leaves blob as the default. |
| o | defined | symbol | gateway-engine | **EngineID (registry)** - The string id that keys an inference engine driver in the abi engine registry (e.g. bench.Options.EngineID, the const EngineID="inkernel"); New(engineID) binds a kernel to it. |
| o | defined | metric | gateway-engine | **EngineCalls (counter)** - The coordinator-kernel counter (kernel.Counters.EngineCalls, mirrored into agent/gateway metrics) of tool-call reaps that actually dispatched to the engine rather than being served from the vDSO. |
| o | defined | symbol | gateway-engine | **EngineModel (provenance)** - The model identifier the benchmark engine ran under, recorded in bench.Options.EngineModel and stamped into the report Provenance. |
| o | defined | symbol | gateway-engine | **EngineRoute (modelroute)** - The modelroute.Target method returning the locality-leading route string (e.g. "local:..." / "anthropic:...") that the host stamps into abi.ToolCall.Engine for residency classification. |
| o | defined | symbol | gateway-engine | **RegisterEngine** - The abi registry function that adds an inference engine driver keyed by id (local/remote/multi); modelengine and others call it from init(). |
| o | defined | symbol | gateway-engine | **RegisterReadEngine** - agent.RegisterReadEngine registers the working-tree-confined read engine under FakReadEngineID, so a cache-missed fak_read dispatches to a real confined disk read. |
| o | defined | symbol | gateway-engine | **FakReadEngineID** - The const engine id "fakread" that fak_read binds on its abi.ToolCall so the kernel routes the call to the confined read engine. |
| o | defined | symbol | gateway-engine | **LifecycleEngine** - The optional abi extension interface (admit -> per-step -> stream -> reclaim) an engine implements when it advertises EngineLifecycleCap, giving the gateway a streaming decode lifecycle. |
| o | defined | symbol | gateway-engine | **EngineRequest** - One in-flight decode admitted to a LifecycleEngine; its Tokens() channel streams the decode steps. |
| o | defined | symbol | gateway-engine | **EngineToken** - One streamed decode step from a LifecycleEngine — the generated token id plus optional bytes. |
| o | defined | symbol | gateway-engine | **EngineLifecycleCap** - The abi.Capability ("engine.lifecycle.v1") an engine advertises from Caps() when it implements LifecycleEngine, so a consumer can detect lifecycle support. |
| o | defined | symbol | gateway-engine | **gatewayMetrics (registry)** - The gateway's in-process metrics aggregator struct (constructed by newGatewayMetrics) that tallies HTTP, operation, inference, and in-kernel-OOM counters and renders the /metrics Prometheus exposition. |
| o | defined | symbol | gateway-engine | **GatewayURL (field)** - The gateway base URL a client is pointed at — e.g. the dropin child's loopback gateway_url and computeTarget.GatewayURL for a gateway-kind compute target. |
| o | defined | symbol | gateway-engine | **GatewayAddr (swebench)** - The fak gateway address (host:port, default localhost:8080) the swebench integrator uses to build a Planner against a running gateway. |
| o | defined | symbol | gateway-engine | **targetGatewayURL (compute kind)** - The compute-target kind constant ("gateway-url") in cmd/fak/computetarget.go selecting an existing fak/OpenAI-compatible gateway reached over HTTP as the compute backend. |
| o | defined | config | gateway-engine | **FAK_GATEWAY_KEY** - The environment variable holding the gateway bearer credential that fak CLI subcommands send when a gateway runs with --require-key. |
| o | defined | symbol | gateway-engine | **defaultGatewayBearerToken** - The cmd/fak helper that resolves the default bearer credential (from FAK_GATEWAY_KEY via the secret loader) used as the --key default across fak CLI subcommands. |
| o | defined | symbol | gateway-engine | **FakGateway (browseraction)** - The browseraction contract field naming the fak gateway base URL the browser-action agent is pointed at (e.g. http://localhost:8080/v1). |
| o | defined | doc-term | gateway-engine | **StatusBadGateway (HTTP 502)** - The net/http StatusBadGateway (502) constant the gateway returns when an upstream provider is unreachable, returns an unrecognized tool-call format, or fails cache invalidation. |
| o | defined | metric | gateway-engine | **fak_gateway_up** - The Prometheus gauge that is 1 when the fak gateway process is scrapeable. |
| o | defined | metric | gateway-engine | **fak_gateway_build_info** - The Prometheus gauge (value 1) carrying static fak gateway build/runtime labels (version, engine, model, vdso). |
| o | defined | metric | gateway-engine | **fak_gateway_http_requests_total** - The Prometheus counter of HTTP requests the gateway served, labeled by route, method, and status. |
| o | defined | metric | gateway-engine | **fak_gateway_http_request_duration_seconds** - The Prometheus histogram of gateway HTTP request latency, labeled by route, method, and status. |
| o | defined | metric | gateway-engine | **fak_gateway_operations_total** - The Prometheus counter of gateway kernel operations labeled by operation, verdict, reason, disposition, and deciding adjudicator (by). |
| o | defined | metric | gateway-engine | **fak_gateway_inflight_requests** - The Prometheus gauge of HTTP requests currently executing inside the gateway. |
| o | defined | metric | gateway-engine | **fak_gateway_time_to_ready_seconds** - The Prometheus gauge of total wall-clock from process start to the gateway becoming ready to serve (0 until ready). |
| o | defined | metric | gateway-engine | **fak_gateway_startup_phase_duration_seconds** - The Prometheus gauge of each named gateway boot phase's wall-clock cost (flag-parse, policy-load, planner-init, vdso-config, kernel-init, listener-bind, model-load). |
| o | defined | metric | gateway-engine | **fak_gateway_startup_unaccounted_seconds** - The Prometheus gauge of boot wall-clock not explained by any named startup phase (time_to_ready minus the sum of phase durations); near-zero means startup is fully instrumented. |
| o | defined | metric | gateway-engine | **fak_kernel_decisions_total** - The Prometheus counter of the gateway's passive rung-decision distribution (rungObs), labeled by rung, kind, and reason. |
| o | defined | metric | gateway-engine | **VDSOHits (counter)** - The coordinator-kernel counter of tool calls served from the vDSO fast path without dispatching to the engine. |
| o | defined | metric | gateway-engine | **VDSOHitRate (ratio)** - The fraction of kernel submissions served by the vDSO fast path (VDSOHits/Calls), surfaced as bench.Report.VDSOHitRate and the fak_gateway_vdso_hit_ratio / fak_vdso_hit_rate gauges. |
| o | defined | symbol | gateway-engine | **SetVDSO** - The Kernel method that toggles the vDSO fast path on/off (the --vdso ablation, unit 5); off makes every call fall through to adjudication + engine. |
| o | defined | symbol | gateway-engine | **VDSOEnabled** - The Kernel method reporting whether the vDSO fast path is currently active. |
| o | defined | symbol | gateway-engine | **vdsoOff (ablation)** - The Kernel field / `--vdso=off` ablation flag that, when set, makes Submit skip the FastPath entirely — the 'off' arm of the A/B benchmark. |
| o | defined | symbol | gateway-engine | **vdsoOn (arm)** - The vDSO-enabled benchmark arm — the RunArm vdsoOn=true call labeled "vdso_on" that serves repeats from the fast path. |
| o | defined | symbol | gateway-engine | **VDSOPure (tier-1)** - The turnbench ClassBreakdown count of tier-1 'pure local serve' vDSO hits (e.g. deterministic calculate calls). |
| o | defined | symbol | gateway-engine | **VDSODedup (tier-2)** - The turnbench ClassBreakdown count of tier-2 vDSO hits served from the content cache on a duplicate read (the 'vdso_tier2' source). |
| o | defined | symbol | gateway-engine | **VDSOStatic (tier-3)** - The turnbench ClassBreakdown count of tier-3 'static local serve' vDSO hits (e.g. list_all_airports). |
| o | defined | subsystem | gateway-engine | **modelengine** - The binding that wires the in-kernel model into the kernel as a registered EngineDriver under the id 'inkernel'. |
| o | defined | subsystem | gateway-engine | **modelroute** - The model-routing policy spine: a version-tagged JSON manifest that classifies a tool call by aspect into a plan for which model(s) serve each aspect. |
| o | defined | subsystem | gateway-engine | **xenginekv** - The cross-engine zero-copy KV co-residence seam: a RegionBackend that maps an external engine's KV cache and fak's args/results into one shared addressable arena. |
| o | defined | subsystem | guard-gate | **guardrsi (guard-verdict-RSI fold)** - The internal/guardrsi package that folds a guarded session's hash-chained decision journal and finds the dominant honesty-hole bucket (WorstBucket) to drive the guard-verdict RSI loop. |
| o | defined | subsystem | guard-gate | **guardroute (RSI route decision)** - The internal/guardroute bridge that turns guardrsi's worst journal bucket into a routed, idempotent, escalating finding (a queue row and, for a real honesty-hole, a deduped GitHub issue), closing the guard RSI loop. |
| o | defined | subsystem | guard-gate | **guardcomplaint (agent appeal channel)** - The internal/guardcomplaint package behind `fak complain`: the SUBJECTIVE appeal channel where an agent reports a false-positive DENY, the complement of guardroute's objective journal-fold routing. |
| o | defined | subsystem | guard-gate | **guarddemo (safety-floor demo)** - The cmd/guarddemo command: the live on-box demo that replays the same attack trace twice (with and without fak) to show the SAFETY FLOOR refusing destructive/exfiltration tool calls. |
| o | defined | symbol | guard-gate | **guardStopHook (deny-all continue hook)** - The cmd/fak guard Stop-hook half of the deny-all false-stop fix: when the floor refused EVERY tool call in a turn (reported as end_turn), it auto-RESUMES the agent, bounded by warn/final consecutive-continue limits. |
| o | defined | symbol | guard-gate | **guardMcpStatusAudit (guard MCP-status audit)** - The guard_mcp_status_audit make-hygiene checker (schema fak-guard-mcp-status-audit/1) that audits whether the guard's default MCP blockers are in place and surfaces them in the TUI guard pane. |
| o | defined | symbol | guard-gate | **tuiGuardReport (TUI guard pane model)** - The cmd/fak TUI data model for the guard pane: tuiGuardReport (built by buildTUIGuardReport from artifacts loaded by loadTUIGuard) holds the counts, rows, and sources rendered as the guard overview card. |
| o | defined | symbol | guard-gate | **cmdGuard (fak guard entry point)** - The cmd/fak entry function for `fak guard`: it resolves the upstream wire, stands up the gateway, builds the child command (buildGuardChild) with the injected base-URL env (guardInjectedEnv), and execs the wrapped agent through the kernel. |
| o | defined | symbol | guard-gate | **guardProvider (upstream wire resolver)** - The cmd/fak guard provider-resolution family: GuardProvider/resolveGuardProvider/guardDetectProvider pick the upstream API wire (anthropic/openai/...) for a guarded session, inferring it from the wrapped agent's base name (guardAgentBaseName). |
| o | defined | config | guard-gate | **guardDefaultBaseURL (provider base-URL map)** - The cmd/fak guard base-URL config helpers: guardDefaultBaseURL maps a provider to its public API base, guardOpenAIV1Base appends the /v1 the OpenAI-compatible wire expects, and fleetDogfoodGuardBaseURL is the fleet dogfood default. |
| o | defined | config | guard-gate | **guardedLaunchCommand (guarded-launch wiring)** - The dispatch/guard launch + session config helpers: GuardedLaunchCommand fronts a worker command with `fak guard`, guardEnabled gates whether to do so, guardEnvValue/guardedGlobs/guardLocalModelDecision/guardTimeoutFloors/guardWaitHealthy supply the session's env, scope, model and readiness wiring. |
| o | defined | config | guard-gate | **guardDefaultAuditPath (decision-journal path)** - The cmd/fak guardDefaultAuditPath helper: the per-user default filesystem path where `fak guard` writes its durable hash-chained decision journal when FAK_AUDIT_JOURNAL is unset. |
| o | defined | config | guard-gate | **guardPreCompactMode (PreCompact hook mode)** - The off|shadow|enforce mode constants for `fak guard`'s Claude-Code PreCompact / Stop hooks: guardPreCompactModeOff disables, guardPreCompactModeShadow logs the would-block while exiting 0, and guardPreCompactModeEnforce returns the blocking exit code. |
| o | defined | symbol | guard-gate | **installGuardCodexConfig (codex routing rewrite)** - The cmd/fak installGuardCodexConfig function: the only thing that puts the kernel in front of Codex, rewriting a `codex` child command with Codex-specific `-c` flags so it routes through the guard gateway. |
| o | defined | metric | guard-gate | **GuardRefusals (refusal-count signal)** - The sessionobs.Signals counter that tallies how many times the guard refused a tool call in a session (deny + kernel-deny + per-turn floor refusals), excluding quarantines. |
| o | defined | symbol | guard-gate | **CheckGate (report CI-gate method)** - The report-level CI gate on cadencereport/dojo/gardenbundle reports: CheckGate(report) returns an exit code plus message, and WithGate folds that gate result (gateExit / gateMessage) back into the emitted report. |
| o | defined | symbol | guard-gate | **gateSend (A2A capability floor)** - The internal/a2achan capability-floor functions gateSend (send-time) and gateRecv (recv-time): the one fail-closed source of truth the agent-to-agent Bus and replay call to admit or deny a channel message by capability. |
| o | defined | symbol | guard-gate | **GateTokenWrite (account twin-guard)** - The internal/accounts twin-guard GateTokenWrite: it twin-checks before writing an account's .oauth-token so a credential is never smeared across two distinct accounts in one seat directory. |
| o | defined | metric | guard-gate | **MinGateTurns (cache-value gate threshold)** - The cachevalueledger cache-value gate accounting: MinGateTurns is the minimum number of multi-turn turns required before the regression gate enforces, while GatePromptTokens / GateReusedTokens are the prompt/reused token tallies that gate folds over. |
| o | defined | symbol | guard-gate | **gateTurn (per-turn session gate)** - The internal/agent gateTurn method: it applies the per-turn SessionGate at a turn boundary, returning the per-turn token cap, a proceed bool, and a stop reason (and sleeping any throttle gap) — wired by WithSessionGate. |
| o | defined | symbol | guard-gate | **gateDocPlacement (git-hook check function)** - The internal/hooks staged-diff commit-boundary check functions: gateDocPlacement (doc placement rule), gateProvenanceLabel (provenance labels), and gatePublicLeak (public-leak scrub) each scan a StagedDiff and return findings. |
| o | defined | config | guard-gate | **GatedSinks (egress-sink policy data)** - The internal/ifc GatedSinks policy data: the configured set of egress/destructive/exec sink classes the SinkGate adjudicator reads to decide whether tainted arguments may flow into a sink. |
| o | defined | subsystem | guard-gate | **pythongate (no-new-python-tools ratchet)** - The internal/pythongate leaf: a ratchet (TestNoNewPythonTools) that refuses introducing new Python tool scripts, holding the line on the Go-first tooling preference. |
| o | defined | subsystem | guard-gate | **loopgate (loop done-witness gate)** - The internal/loopgate leaf: the STOP gate for the verified loop that adjudicates whether a goal is witnessed-done, returning verdicts like NotYet with reasons (DoneUnwitnessed) over criteria such as commit-audit or citation-resolve. |
| o | defined | subsystem | guard-gate | **windowgate (no-desktop-popup gate)** - The internal/windowgate leaf: the no-desktop-popup gate (TestTrackedTreeHasNoPopups) that refuses code which would raise a blocking desktop window/popup. |
| o | defined | subsystem | guard-gate | **benchlineagegate (bench-emitter lineage gate)** - The internal/benchlineagegate leaf: the durable enforcement gate (TestEveryBenchEmitterStampsLineage) that requires every benchmark emitter to stamp its lineage. |
| o | defined | symbol | guard-gate | **residencyGate (engine-residency adjudicator)** - The internal/engine residencyGate: the rank-12 engine-residency Adjudicator that DENIES a tenant-scoped tool call routed to a remote/off-device path (ReasonTrustViolation). |
| o | defined | symbol | guard-gate | **SmokeGate (swebench smoke-check gate)** - The internal/swebench SmokeGate: one named smoke-check row in the opus-smoke harness (rendered by renderSmokeGatesTable as a Gate | OK | Detail markdown table) recording whether a pre-run readiness check passed. |
| o | defined | symbol | guard-gate | **gateUp (FFN gate+up split locals)** - Local identifiers in internal/model's weight-loading code: gateUp is the concatenated gate++up tensor in the fused-split path, and gateName is the gate_proj weight's resolved name in the safetensors quantizer. |
| o | defined | symbol | guard-gate | **NewGate (headroom/rehydrate gate constructor)** - The NewGate constructors in internal/headroom and internal/rehydrate: each builds a fresh admission Gate (independent counters / sorted rungs) used as a post-call admit ladder. |
| o | defined | symbol | guard-gate | **newLiftGuard (stream lift guard)** - The internal/gateway newLiftGuard constructor: builds the streaming lift-guard that watches a model's streamed content (via an emit callback) during the planner/proxy stream path. |
| o | defined | subsystem | guard-gate | **FleetProcResourceGuard (runaway-process guard)** - The FleetProcResourceGuard Windows Scheduled Task (register_proc_resource_guard.ps1): the process-resource peer of the find/grep runaway guard that kills runaway fleet processes by resource budget. |
| o | defined | config | guard-gate | **FAK_GITGATE (gate env toggles)** - The environment-variable toggles for two adjudication rungs: FAK_GITGATE turns the internal/gitgate git-shape prefilter on/off, and FAK_NORMGATE turns the internal/normgate canonicalize-and-rescan ResultAdmitter on/off. |
| o | defined | subsystem | guard-gate | **normgate (result admitter)** - A ResultAdmitter that canonicalizes obfuscated payloads (base64, homoglyph, zero-width) before re-scanning for secrets. |
| o | defined | subsystem | guard-gate | **secretgate (result admitter)** - A ResultAdmitter that classifies discovered credentials as RESULT_SECRET_DISCOVERED events, distinct from injection poisoning. |
| o | defined | symbol | layout | **RecommendLayout (cachemeta)** - cachemeta.RecommendLayout produces the cache-optimal re-ordering of one turn's prompt segments, hoisting every volatile segment (position-independent metadata like a timestamp or request id) to the tail so the most contiguous leading tokens survive as a provider-cacheable prefix, returning a LayoutRecommendation with the predicted uplift. |
| o | defined | symbol | layout | **LayoutRecommendation (cachemeta)** - cachemeta.LayoutRecommendation is the struct returned by RecommendLayout: the reordered segment list, the count of moved volatile segments, the before/after contiguous cacheable-token counts, and the predicted cacheable-token uplift for one turn. |
| o | defined | symbol | layout | **mlaKVLayout (model)** - model.mlaKVLayout is the kvLayout implementation for MLA models that caches a compressed latent c_KV plus a pre-RoPE decoupled key per position, then up-projects the latent to full per-head K/V and rotates the shared key on read, shrinking the cache ~10-50x versus the per-head width. |
| o | defined | symbol | layout | **standardKVLayout (model)** - model.standardKVLayout is the default Llama/Qwen kvLayout: the cache stores post-RoPE K and V directly at width NumKVHeads*HeadDim, so reconstructKV is the identity that splits and hands back the stored rows, keeping the path bit-identical to inline blockStep attention. |
| o | defined | symbol | layout | **modelLayout (model selector)** - model.Model.modelLayout() is the selector method that returns mlaKVLayout when the model has MLA projection geometry (Model.MLA != nil) and otherwise returns the default standardKVLayout, choosing which KV-cache layout a given model uses. |
| o | defined | symbol | plan | **HTTPPlanner (agent client)** - internal/agent's HTTPPlanner is the single outbound chat-completions HTTP client that implements agent.Planner, speaking the OpenAI/Anthropic/Gemini wire to a live upstream model. |
| o | defined | symbol | plan | **MockPlanner (offline)** - internal/agent/mock.go's MockPlanner is a deterministic, offline agent.Planner that emulates a real planner with a fixed scripted sequence, used in CI and as cmd/fak/main.go's fallback. |
| o | defined | symbol | plan | **StreamingPlanner (capability)** - internal/agent's StreamingPlanner is the optional interface a Planner advertises (CompleteStream/StreamingSupported) when it can emit completion tokens incrementally. |
| o | defined | symbol | plan | **CodePlanner (swebench)** - swebench's CodePlanner is the domain interface for a code-edit planner over ChatMessage/ChatTool; cmd/fak's httpCodePlanner adapts an agent.HTTPPlanner to it. |
| o | defined | symbol | plan | **FleetPlanner (swebench fleet)** - cmd/fak's newFleetPlanner (and the swebench config FleetPlanner field) builds the swebench fleet runner's planner from a gateway address and model. |
| o | defined | symbol | plan | **SessionPlanner.PlanTurn (ctxplan)** - internal/agent's SessionPlanner.PlanTurn ingests new messages incrementally, then probes a bounded candidate set to produce a ctxplan resident-context Plan for the turn. |
| o | defined | symbol | plan | **sessionPlanners (gateway cache)** - internal/gateway's sessionPlanners is the Server's bounded map holding one persistent agent.SessionPlanner per session trace id, minted lazily by sessionPlannerFor. |
| o | defined | symbol | plan | **CtxViewPlanner (ctxplan seam)** - internal/agent's CtxViewPlanner is the guarded seam (gated by FAK_CTXPLAN_SEAM) whose PlanTurn lowers a turn's running messages into a lossless ctxplan View; disabled, it is an inert identity. |
| o | defined | symbol | plan | **maybePlanMessages (gateway)** - internal/gateway's Server.maybePlanMessages is the per-request hook that, when the ctxplan seam is enabled, rewrites the forwarded message history via the per-session planner; otherwise it returns the history byte-for-byte unchanged. |
| o | defined | symbol | plan | **MemoryPlan (compute)** - internal/compute's MemoryPlan is the classed form of a 'will this fit?' estimate — a list of MemoryDemand rows split into device- and host-scoped totals. |
| o | defined | symbol | plan | **FitsMemoryPlan (compute)** - internal/compute's FitsMemoryPlan returns a fail-open fit verdict for a classed MemoryPlan, checking device-scoped bytes against the device probe and host-scoped bytes against the host probe. |
| o | defined | symbol | plan | **RefuseMemoryPlanIfTooBig (compute)** - internal/compute's RefuseMemoryPlanIfTooBig turns a too-big MemoryPlan into an error (refusal) against a backend's device headroom, used by serve and the in-kernel planner before admitting a request. |
| o | defined | symbol | plan | **EstimateLoadMemoryPlan (ggufload)** - internal/ggufload's WeightSource.EstimateLoadMemoryPlan builds a classed compute.MemoryPlan for loading a GGUF model's weights grouped by dtype; the F32-resident and CPU-offload-experts variants specialise it. |
| o | defined | symbol | plan | **EstimateKVStoreMemoryPlan (compute)** - internal/compute's EstimateKVStoreMemoryPlan is the classed form of the KV-cache store estimate; EstimateHALTransientMemoryPlan is the matching transient/scratch-buffer estimator. |
| o | defined | symbol | plan | **requestMemoryPlanSnapshot (gateway)** - internal/gateway's requestMemoryPlanSnapshot is a captured record of the in-kernel planner's per-request memory plan (class/dtype demand rows), accumulated for the debug and metrics surfaces. |
| o | defined | symbol | plan | **observePlannerRequestMemory (gateway)** - internal/gateway's Server.observePlannerRequestMemory samples the in-kernel planner's last per-request memory plan into the gateway's Prometheus gauges. |
| o | defined | symbol | plan | **plannerErrorStatus (gateway)** - internal/gateway's Server.plannerErrorStatus maps an error returned by the upstream planner to an HTTP status, error code, and message for the chat/messages responses. |
| o | defined | symbol | plan | **plannerKind (gateway)** - internal/gateway's plannerKind classifies the /v1/chat/completions backend (in-kernel / proxy / mock) as a label for the /healthz response. |
| o | defined | symbol | plan | **PlannerReplica (gateway)** - internal/gateway's PlannerReplica is one statically-declared upstream (Name + Planner) in a gateway fleet, consumed by the ReplicaRouter. |
| o | defined | symbol | plan | **streamAnthropicPlannerLive (gateway)** - internal/gateway's Server.streamAnthropicPlannerLive translates a generic planner's live content stream into Anthropic /v1/messages SSE events. |
| o | defined | symbol | plan | **ComposePlannerBudget (session pace)** - internal/session's Pace.ComposePlannerBudget scales a base resident-context window down by the Pace throttle ratio, floored at base/MinPlannerBudgetDivisor. |
| o | defined | symbol | plan | **PlannerComputeCum (ctxplan scaling)** - internal/ctxplan's PlannerComputeCum is the cumulative O(N^2) re-planning WORK through turn N in the Planned regime (computed by cumPlannerCompute) — a scaling-curve cost proxy. |
| o | defined | symbol | plan | **IndexBoundedPlannerCompute (ctxplan)** - internal/ctxplan's IndexBoundedPlannerCompute is the cumulative re-planning work through turn N when each turn scores only a bounded candidate set — Theta(c*N), flattening the quadratic cumPlannerCompute. |
| o | defined | symbol | plan | **PlanCells (ctxplan)** - internal/ctxplan's Index.PlanCells selects spans within a token Budget from a Forecast to produce a resident-context Plan. |
| o | defined | symbol | plan | **PlanLayout (ctxplan)** - internal/ctxplan's Index.PlanLayout plans an O(1) resident view using the flexible four-area layout (e.g. Recent/Deep areas with per-area policies). |
| o | defined | symbol | plan | **PrecisionPlanned (ctxplan)** - internal/ctxplan's PrecisionPlanned ('planned') is the span precision meaning a normal candidate that may be selected exactly or elided by the optimizer. |
| o | defined | symbol | plan | **PlannedTokens (inkernel memory)** - internal/agent's PlannedTokens is the prompt+max-new token count the in-kernel planner's per-request memory plan is sized for, recorded on the request-memory observation. |
| o | defined | symbol | plan | **MaxCandidates (ctxplan probe)** - internal/ctxplan's ProbeOptions.MaxCandidates (default DefaultMaxCandidates) caps the bounded candidate set the per-turn probe scores, keeping re-planning O(1) per turn. |
| o | defined | symbol | plan | **CandidateTaskIDs (browseraction)** - internal/browseraction's CandidateTaskIDs is the list of benchmark task ids selected for an action-mediation contract, alongside CandidateSuite and CandidateTasks. |
| o | defined | symbol | plan | **ContractTaskCandidate (browseraction)** - internal/browseraction's ContractTaskCandidate is one task record in a contract's candidate set (built by contractTaskCandidates; candidateTaskDetail renders its count). |
| o | defined | symbol | plan | **CandidatesTokenCount (Gemini usage)** - internal/agent's CandidatesTokenCount is the Gemini usage-metadata field counting tokens across the model's response candidates, mapped into CompletionTokens. |
| o | defined | symbol | plan | **TopologyCandidate (turnbench)** - internal/turnbench's TopologyCandidate is a scored multi-agent topology shape produced by the topology search. |
| o | defined | symbol | plan | **SearchCandidate (turnbench)** - internal/turnbench's SearchCandidate is one searched policy genome plus its measured fitness in the policy search. |
| o | defined | symbol | plan | **pythonCandidates (webbench)** - internal/webbench's pythonCandidates returns the ordered list of python interpreter names/paths to probe when locating a usable interpreter. |
| o | defined | symbol | plan | **PlanTemplate (cachemeta)** - internal/cachemeta's PlanTemplate is an advisory, reusable plan-template cache artifact keyed by intent (media type MediaPlanTemplate, carrying a PlanSchemaDigest), reused across turns like a prepared statement. |
| o | defined | subsystem | plan | **plancfi (package)** - internal/plancfi is control-flow integrity for an agent's PLAN — a stateful per-trace adjudicator that refuses (or escalates) a tool call that deviates from the operator-approved plan. |
| o | defined | symbol | plan | **BuildPlan (action planner)** - BuildPlan is the verb-named function (in internal/dogfoodissues and internal/stopfailure) that diffs inputs into a concrete list of actions — e.g. create-vs-update GitHub issues, or stale-session resets. |
| o | defined | symbol | plan | **PlanReport (nightrun)** - internal/nightrun's PlanReport is the stable --json shape emitted by `fak nightrun plan` — the ranked overnight collection-task plan. |
| o | defined | symbol | plan | **PlanFor (dropin)** - internal/dropin's PlanFor composes the drop-in resolution plan for a named CLI agent (claude/codex/...) against a gateway, autodetecting the provider. |
| o | defined | symbol | plan | **PlanPlacementForDevice (engine)** - internal/engine's PlanPlacementForDevice plans a cachemeta placement decision (keep / demote / evict) for a request against the device that actually exists and its resident bytes. |
| o | defined | symbol | plan | **PlanFleetReuse (cachemeta)** - internal/cachemeta's PlanFleetReuse computes the three-way fleet economics for one hot prefix shared across the fleet (a deterministic, payload-free calculation). |
| o | defined | symbol | plan | **PlanWarmBudget (vcachegov)** - internal/vcachegov's PlanWarmBudget computes the warm-keep token budget for a cache tier from its headroom, RPM, and TTL (the keep-warm crossover). |
| o | defined | symbol | plan | **PartitionPlan (model)** - internal/model's PartitionPlan (built by NewPartitionPlan) is a pipeline-partition plan that cuts a model's layers into pipeline stages. |
| o | defined | symbol | plan | **TPPlan (model)** - internal/model's NewTPPlan builds a tensor-parallel plan: the row/column tiling of a layer's matrices across TP ranks. |
| o | defined | symbol | plan | **ResolvedPlan (modelroute)** - internal/modelroute's ResolvedPlan binds a routed Plan to concrete targets (the optional Scout plus the resolved roster), produced by Roster.ResolvePlan. |
| o | defined | symbol | plan | **ReplayPlan (vcachechain)** - internal/vcachechain's ReplayPlan is the topological replay schedule (send-one-then-fan) for warming a set of cache targets, produced by PrefixDAG.TopologicalReplay. |
| o | defined | symbol | plan | **ToolPlan (promptmmu)** - internal/promptmmu's ToolPlan is the spine's pure, caller-supplied verdict (e.g. a Drop set) over a request's tools, driving inbound tool compaction. |
| o | defined | doc-term | plan | **replan (recovery verb)** - In fak's refusal/routing vocabulary (cmd/fak/commit.go, internal/gateway/routing.go) to 'replan' is the recovery action when a commit or route is BLOCKED — discard the attempt and compute a fresh plan rather than retrying it verbatim. |
| o | defined | symbol | plan | **idxPlan (ctxplan index-bounded view)** - idxPlan is the local ctxplan.Plan produced by index.PlanCells in cmd/ctxplandemo and cmd/ctxplanbench, the O(1) resident view scored over only an index-bounded candidate set rather than the full transcript. |
| o | defined | symbol | plan | **planAudit (ctxplan faithfulness witness)** - ctxplan.Audit(p Plan) returns the Witness that a planned resident view is faithful (no candidate span destroyed), the same plan-faithfulness check tools/plan_audit_test.py exercises. |
| o | defined | symbol | plan | **PlanOf (syspromptmmu prompt-segment plan)** - syspromptmmu.PlanOf folds a base Segment list into the []cachemeta.PromptSegment system-prompt plan that BuildSystemValue realizes, and BaseContextPlan seeds the resident spine-plus-policy floor of that plan. |
| o | defined | symbol | plan | **AutoSizeContextPlan (compute headroom sizer)** - compute.AutoSizeContextPlan takes a ContextSizeConfig and a MemoryPlan weight set plus available bytes and returns the auto-sized context token budget and the fitted MemoryPlan for a serve. |
| o | defined | symbol | plan | **vulkan_plan (Vulkan command-buffer compute plan)** - internal/compute/vulkan_plan.go is the host-tractable scaffold for issue #10's Vulkan command-buffer wiring, the compute-side plan of which cold weights spill on a discrete GPU. |
| o | defined | symbol | plan | **ExpertParallelPlan (MoE expert partition plan)** - ExpertParallelPlan(numExperts, ranks) is the named GLM-5.2 expert-parallel partition that splits the Mixture-of-Experts experts across ranks, per docs/notes/GLM52-EXPERT-PARALLEL-MULTIGPU. |
| o | defined | symbol | plan | **ScriptedPlanner (agenttest fixture)** - internal/agenttest's ScriptedPlanner is a deterministic agent.Planner test fixture that emits a fixed sequence of turns, built by NewScriptedPlanner and used by RunSession. |
| o | defined | symbol | plan | **ReplayPlanner (agenttest transcript replay)** - internal/agenttest's ReplayPlanner is a deterministic agent.Planner that re-emits the assistant turns of a recorded transcript, built by NewReplayPlanner. |
| o | defined | symbol | plan | **NewInKernelPlanner (local GGUF planner ctor)** - agent.NewInKernelPlanner builds the in-kernel agent.Planner that decodes a local GGUF model in-process (used by run_model.go and the gateway's --gguf in-kernel generation path). |
| o | defined | config | plan | **plannerTimeout (agent HTTP per-call timeout)** - internal/agent/chat.go's plannerTimeout is the per-request upstream-model HTTP timeout (60s default, FAK_PLANNER_TIMEOUT_S override, clamped to [5,3600]), and plannerMaxAttempts is the total upstream try count for that same path. |
| o | defined | symbol | plan | **BuildIssuePlan (maturity issue create/update plan)** - internal/maturity.BuildIssuePlan decides whether each maturity item creates a new GitHub issue or updates an existing one, and SyncIssuePlan applies that planned create/update set via gh. |
| o | defined | symbol | plan | **BuildHandoffIssuePlan (taskmgr handoff issue plan)** - internal/taskmgr.BuildHandoffIssuePlan decides create vs update for every next step of a Handoff, emitting HandoffIssuePlanRow rows that syncTaskHandoffPlan applies via gh. |
| o | defined | symbol | plan | **PlanRow (issue create/update decision row)** - PlanRow is the one-issue create/update decision struct emitted by BuildPlan in internal/dogfoodissues and internal/learningdebt (and guardcomplaint.PlanRow), one row per ActionItem or Defect. |
| o | defined | symbol | plan | **PlanItem (loopdrive goal step)** - internal/loopdrive.PlanItem is one parsed step of a loop-drive goal plan (produced by parsePlan), carrying the Text the loop drives toward turn by turn. |
| o | defined | symbol | plan | **PlanIndex (vcachescore hot-anchor index)** - internal/vcachescore.PlanIndex chooses the smallest hot-anchor index reaching a target coverage from a vcachecal.Concentration, returning an IndexPlan. |
| o | defined | symbol | plan | **benchpost.RequestFromPlan (bench_plan fold)** - internal/benchpost folds a bench_plan.py --json payload into a run-request Post via RequestFromPlan, with LoadPlan/ParsePlan decoding the payload and formatPlanRow rendering each planRow. |
| o | defined | symbol | plan | **Roster.ResolvePlan (modelroute member resolver)** - internal/modelroute's Roster.ResolvePlan and Registry.ResolvePlan bind every member of a routed Plan (the optional Scout plus the roster) to concrete resolved targets, producing a ResolvedPlan. |
| o | defined | symbol | plan | **RotationPlan (accounts seat rotation)** - internal/accounts.Registry.RotationPlan classifies every home and returns the rotation pool of eligible seats with its policy, driving account/seat rotation. |
| o | defined | symbol | plan | **StagePlan (loopindex collision-priced stage)** - loopindex.StagePlan is the named loop-index stage whose signal is collision-priced fan-out coverage with a fitness floor, used in cmd/fak/loopindex.go. |
| o | defined | symbol | plan | **PlanPlacementForHost (engine host placement)** - internal/engine.PlanPlacementForHost (and PlanPlacementForDeviceAndHost) plans a cachemeta placement against the host that actually exists, the host-DRAM-pressure half of issue #1073's wire. |
| o | defined | symbol | plan | **RefuseHostScopedPlanIfTooBigForHost (cpu-offload host fit)** - internal/compute.RefuseHostScopedPlanIfTooBigForHost is the --cpu-offload-experts counterpart of RefuseMemoryPlanIfTooBigForHost: on a device serve with cpu-offloaded MoE it refuses a MemoryPlan that will not fit host RAM (#974, #971). |
| o | defined | symbol | plan | **CandidateBound (ctxplan index-bounded set size)** - internal/ctxplan's CandidateBound is the index-bounded candidate-set size c the Planned regime priced each turn, defaulting to DefaultMaxCandidates and feeding IndexBoundedPlannerCompute. |
| o | defined | symbol | plan | **KVPressureCandidate (gateway wire-neutral evict candidate)** - gateway.KVPressureCandidate is a wire-neutral KV span the post-turn pressure relief may evict, supplied by a KVPressureCandidateProvider and lowered into engine.CapacityPressureCandidate. |
| o | defined | symbol | plan | **PrewarmCandidate (compute prewarm admission input)** - internal/compute.PrewarmCandidate is one tool-call boundary the scheduler decides about for tool-latency prewarm admission (DecidePrewarmAdmission), carrying the WarmPoolFree pollution gate. |
| o | defined | symbol | plan | **RankCandidates (dojocal recalibration ranking)** - internal/dojocal.RankCandidates orders dojo recalibration candidates by candidatePriority, and NextCandidate returns the top-ranked scored candidate for the next tick. |
| o | defined | symbol | plan | **candidateIDLabel (bench task-count pluralizer)** - candidateIDLabel is the bench-harness helper (cmd/terminalbench, browseractionbench, toolsandboxbench) that pluralizes the count of CandidateTaskIDs in a TaskSelection for the tasks status line. |
| o | defined | symbol | plan | **candidate_tag (releasestatus promotion candidate)** - internal/releasestatus's candidateTag/candidateSHA name the latest rolling tag (and its commit) being evaluated for stable promotion, with no_candidate the state when no rolling tag exists. |
| o | defined | symbol | plan | **PlanTick (gardenbundle)** - gardenbundle.PlanTick(results, dryRun) computes a TickPlan - the decided set of stale-work reap and surface actions for one garden tick from the member results. |
| o | defined | symbol | plan | **TickPlan (gardenbundle)** - gardenbundle.TickPlan is the value PlanTick returns: the decided reap/surface counts for one garden tick, with Acted() true when the tick will change anything. |
| o | defined | symbol | plan | **LaneCandidate (dispatchtick)** - dispatchtick.LaneCandidate is one orderable issue in a dispatch lane: its number and the priority signal orderLaneCandidates ranks it by. |
| o | defined | symbol | plan | **dispatchWaveCandidate** - cmd/fak dispatchWaveCandidate is one lane chosen to run in a dispatch wave - a RunTarget in the wave price, the lane-level unit the wave admits under disjointness. |
| o | defined | concept | policy-capability | **adjudicating (the decision act)** - Adjudicating is the act of evaluating a proposed tool call (or a buffered turn of them) against the loaded policy and refusal rungs to produce an admit/refuse verdict, exercised on the gateway's served fast path (adjudicateProposedServed), its full-turn gate (adjudicateProposedTurn), and folded into the deny-all counter by recordAdjudicationOutcome. |
| o | defined | config | policy-capability | **posture enum value (per-subsystem stance)** - These are named stance constants on different subsystems' Posture enums: resume's PostureCold/PostureWarm/PostureUnknown classify whether a session's provider prefix is still cache-warm, compactcohere's PostureBlock is the PreCompact-hook stance that exits 2 to block harness auto-compaction, and adjudicator's PostureFailClosed is the default-deny tool-admission stance. |
| o | defined | symbol | policy-capability | **DispatchPreflight (dispatch admission)** - DispatchPreflight (cmd/fak) folds host safety, account availability, kernel capacity, and seat-pool checks (its PreflightInput) into a verdict on whether a new issue-resolution worker may safely spawn, with PreflightReady the ggufload load-time gate verdict that says a model header parsed and fits. |
| o | defined | symbol | policy-capability | **fetch_policy (benchmark refund-doc tool)** - fetch_policy (internal/agent toolFetchDoc) and its sibling read_refund_policy are the agent-benchmark tool names for fetching an airline refund document whose body carries an indirect prompt injection, the call the context-MMU quarantines at result admission to prove the floor. |
| o | defined | symbol | policy-capability | **TierPolicy (ctxresidency tier)** - TierPolicy (internal/ctxresidency) is the always-resident context-residency tier holding the versioned deny/allow and safety-critical floor spans, which are never paged out under budget pressure during context compression. |
| o | defined | symbol | policy-capability | **DefaultAdmissionPolicy (gateway scheduling)** - gateway.DefaultAdmissionPolicy returns the shipping AdmissionPolicy defaults for the request scheduler — a 256-sequence running cap, a token budget, a bounded waiting queue, and per-round aging — bounding how many sequences the engine admits concurrently. |
| o | defined | config | policy-capability | **NativePreemptionPolicy (modelengine scheduler)** - modelengine.NativePreemptionPolicy configures the scheduler's opt-in paged-KV block-pressure preemption path — its mode (swap or recompute), max blocks, and tokens per block — that decides how a running sequence yields KV blocks under memory pressure. |
| o | defined | symbol | policy-capability | **PolicyFor (loopmgr governor)** - loopmgr.Policies.PolicyFor returns the effective loop-governor Policy for a given loop id — the per-loop override if one is registered, else the default loop policy (pause flags, max-consecutive-refusals, aging). |
| o | defined | symbol | policy-capability | **PolicyReplayReport (turnbench)** - turnbench.PolicyReplayReport is the artifact scoring K adjudication-policy variants against one recorded trajectory as model-free kernel replays, carrying per-arm divergence witnesses and cube-collapse cost accounting. |
| o | defined | symbol | policy-capability | **PolicySearch (turnbench genome search)** - turnbench PolicySearch (RunPolicySearch / PolicySearchConfig / PolicySearchReport in policysearch.go) is the model-free replay oracle that hill-climbs the adjudicator deny-set genome over an injection-bearing corpus to find policies that minimize admitted injections at zero model cost. |
| o | defined | symbol | policy-capability | **RegisterCapability (abi)** - abi.RegisterCapability is the registry writer that adds a negotiable feature token to the kernel's process-global Supported() capability set, called from a driver's init(). |
| o | defined | symbol | policy-capability | **RegisterAdjudicator (abi)** - abi.RegisterAdjudicator inserts a PDP/PEP adjudicator link into the kernel's pre-call decision chain at a numeric rank (lower rank runs first) and rebuilds the registry snapshot. |
| o | defined | symbol | policy-capability | **WithAdjudicators (kernel)** - kernel.WithAdjudicators constructs a kernel that folds an EXPLICIT caller-supplied adjudicator chain instead of the process-global registry, so K replay arms each carry their own monitor without colliding. |
| o | defined | symbol | policy-capability | **AdjudicatorsFor (abi)** - abi.AdjudicatorsFor returns the rung chain a given ToolCall must fold in rank order — the unconditional rungs plus any rung tool-scoped to that call — as the registry's immutable slice. |
| o | defined | symbol | policy-capability | **adjudicateProposed (gateway)** - Server.adjudicateProposed gates every proposed tool call in a buffered upstream turn through the kernel, returning the kept calls, per-call ToolAdjudication records, and a dropped count. |
| o | defined | symbol | policy-capability | **handleFakAdjudicate (gateway)** - Server.handleFakAdjudicate is the /v1/fak/adjudicate HTTP handler that returns the pre-execution verdict only — no dispatch, no engine, no pending state — for a client that runs its own tools. |
| o | defined | symbol | policy-capability | **ToolAdjudication (gateway)** - gateway.ToolAdjudication is the per-tool-call record of the kernel's decision on one proposed call — its id, tool, admitted bit, WireVerdict, and any repaired arguments. |
| o | defined | symbol | policy-capability | **AdjudicationSummary (gateway)** - gateway.AdjudicationSummary is the aggregate per-run counter struct (provider token axes, cache reads, decision counts) folded into the guard exit summary. |
| o | defined | symbol | policy-capability | **adjudicationNote (gateway)** - gateway.adjudicationNote renders a short agent-readable in-band summary of a turn's non-trivial decisions (drops + arg repairs) for clients that read only the content channel and never the fak extension. |
| o | defined | symbol | policy-capability | **FakExt.Adjudications (gateway)** - gateway FakExt.Adjudications is the JSON field in the gateway's non-standard response extension carrying the ToolAdjudication record for every tool_call the model proposed, including the dropped ones. |
| o | defined | symbol | policy-capability | **SetPolicy (adjudicator)** - Adjudicator.SetPolicy swaps the live decision table, re-indexing arg predicates and clamping (sanitizeProfile) any profile that tries to drop a mandatory write-class refusal rung. |
| o | defined | symbol | policy-capability | **DefaultPolicy (adjudicator)** - adjudicator.DefaultPolicy is the v0.1 baseline decision table — allow the read-only tool family, fail-closed otherwise — used when no manifest is loaded. |
| o | defined | symbol | policy-capability | **Manifest.ToPolicy (policy)** - policy.Manifest.ToPolicy validates a manifest (version + closed-vocabulary deny reasons) and compiles it into the runtime adjudicator.Policy. |
| o | defined | symbol | policy-capability | **applyPolicy (cmd)** - cmd/fak applyPolicy loads a capability-floor manifest from the --policy path and installs it onto the process-global adjudicator.Default (plus its runtime side-effects) at startup. |
| o | defined | symbol | policy-capability | **policyReloader (cmd)** - cmd/fak policyReloader returns the gateway PolicyReloadFunc that re-loads the capability-floor manifest in-place on a running gateway (re-SetPolicy + runtime apply) and reports a reload summary. |
| o | defined | symbol | policy-capability | **RunPolicyReplay (turnbench)** - turnbench.RunPolicyReplay scores K policy variants against ONE recorded trajectory as model-free kernel replays, emitting per-arm divergence witnesses and the cube-collapse cost accounting. |
| o | defined | symbol | policy-capability | **PolicyArm (turnbench)** - turnbench.PolicyArm is one named policy variant in a same-trace comparison — a label plus the adjudicator.Policy swapped onto the monitor for that arm's replay. |
| o | defined | symbol | policy-capability | **ReasonPolicyBlock (abi)** - abi.ReasonPolicyBlock is the closed-vocabulary reason code (POLICY_BLOCK) the kernel cites when an EXPLICIT policy rule denied a call. |
| o | defined | symbol | policy-capability | **ReasonPolicyMismatch (cachemeta)** - cachemeta.ReasonPolicyMismatch is the cache-lookup MISS reason ("policy_mismatch") returned when a candidate entry's bound policy version no longer matches the live policy. |
| o | defined | symbol | policy-capability | **PolicyVersion (cachemeta)** - cachemeta Validity.PolicyVersion is the policy-version string stamped on a cache entry that bounds its validity, so a policy change invalidates entries minted under the old version. |
| o | defined | symbol | policy-capability | **InvalidationPolicy (cachemeta)** - cachemeta.InvalidationPolicy is the InvalidationMode constant "policy" — the coherence mode that drops a cache entry when policy changes, distinct from the lru/ttl/write_epoch modes. |
| o | defined | config | policy-capability | **LifecyclePolicy (cachemeta)** - cachemeta.LifecyclePolicy parameterizes the time-driven cache-tier transitions — per-tier TTLs, a default TTL, the expiring->expired grace window, and demote-vs-evict on expiry. |
| o | defined | metric | policy-capability | **PolicyEvictions (radixkv)** - PolicyEvictions counts explicit EvictNode calls in the radix KV cache — entries dropped by a deliberate policy action — surfaced as fak_gateway_kv_memory_evictions_total{kind="policy"}. |
| o | defined | config | policy-capability | **DynamicPrecisionPolicy (model)** - model.DynamicPrecisionPolicy is an online quantization controller that accepts a Q8_0 decode result only when the logit top1-top2 margin / top1 probability clears a threshold, else recomputes the span in f32. |
| o | defined | config | policy-capability | **ResetPolicy (gateway)** - gateway.ResetPolicy holds the context-reset decision thresholds (min turns, healthy/stale read ratios, cooldown) that ResetScore folds to recommend a fresh-context reset over another compaction cut; DefaultResetPolicy supplies the conservative defaults. |
| o | defined | config | policy-capability | **BatchPolicy (gateway)** - gateway.BatchPolicy holds the dynamic-batching knobs (max batch, max pad overhead, max prompt length) that bound rectangular-prefill batch selection; DefaultBatchPolicy gives the shipping defaults. |
| o | defined | config | policy-capability | **SecretPosture (adjudicator)** - adjudicator.SecretPosture is the policy-author knob selecting what the on-discovery secret rung does when a tool RESULT bears a credential — quarantine (default), fail_closed, or admit_and_log. |
| o | defined | symbol | policy-capability | **HasPreflightSchema (toollint)** - toollint ToolFacts.HasPreflightSchema is the fact-bit true iff the pre-flight ladder (rung-1) enforces a parameter schema for a tool. |
| o | defined | symbol | policy-capability | **PolicyDenied (toollint)** - toollint ToolFacts.PolicyDenied is the fact-bit true iff the adjudicator policy provably refuses a tool by name via its Deny map. |
| o | defined | symbol | policy-capability | **EvalCapability (swebench)** - swebench.EvalCapability is the probe result describing whether the official grader harness is runnable here — Docker present, swebench importable, the resolved python, and a Runnable bit with a reason. |
| o | defined | symbol | policy-capability | **DetectEvalCapability (swebench)** - swebench.DetectEvalCapability probes the box for Docker and an importable swebench harness and returns the populated EvalCapability with a Runnable verdict and reason. |
| o | defined | metric | policy-capability | **PolicyBreaches (browseraction)** - PolicyBreaches counts the policy-violating actions an arm took during a benchmark task (browser-action / terminal-bench), feeding the SafeSuccess gate. |
| o | defined | metric | policy-capability | **PolicyBreachRate (bench)** - PolicyBreachRate is the arm-level ratio of policy breaches to total actions/commands in a benchmark summary. |
| o | defined | metric | policy-capability | **PolicyBreachDelta (bench)** - PolicyBreachDelta is the raw-arm-minus-fak-arm difference in policy breaches, the head-to-head measure of how many violations the fak floor prevented. |
| o | defined | symbol | policy-capability | **Policy (loaded)** - The in-memory decision table compiled from a manifest, holding allow-lists, deny maps, arg predicates, posture, and secret patterns the adjudicator consults. |
| o | defined | subsystem | policy-capability | **preflight ladder** - The cheapest-first well-formedness rung ladder that catches malformed / unsafe calls before they fire, registered ahead of the authoritative monitor. |
| o | defined | symbol | pool | **PagedKVPool (paged KV block pool)** - model.PagedKVPool (internal/model/pagedkv.go) is the shared pool of fixed-size physical KV blocks every paged sequence draws from with reference-counted copy-on-write; NewPagedKVPool builds a 2-plane K/V pool, and NewPagedKVPoolWithRaw builds a 3-plane pool that adds the pre-RoPE Kraw plane so exact-span eviction can re-rotate survivors in a single rotation. |
| o | defined | symbol | pool | **BuildSeatPool (dispatchtick accounts)** - dispatchtick.BuildSeatPool folds account rows and seat leases for a product into a SeatPoolResult — the available agent-seat capacity by account the dispatcher draws a worker from. |
| o | defined | symbol | pool | **L3PoolWitness (gateway deletion probe)** - gateway.L3PoolWitness is the minimal control-path probe interface the L3 deletion rung folds — an exists/mget over page keys that returns only presence booleans, never page payload bytes — so a deletion certificate can attest an L3 page pool no longer holds a subject's pages. |
| o | defined | symbol | pool | **Pool (polymodel residency)** - polymodel.NewPool (internal/polymodel/polymodel.go) constructs a model-RESIDENCY pool that keeps many prefill-warm models resident under one weight-byte budget, evicting the coldest UNPINNED model (LRU) when an admission would exceed the cap. |
| o | defined | symbol | pool | **DefaultPoolProfiles (cachemeta)** - cachemeta.DefaultPoolProfiles returns a representative PoolProfile per residency tier — HBM/DRAM/NUMA-far host-private, CXL the coherent switch-pooled zero-copy tier, disk local, remote reachable-but-copy-only — the order-of-magnitude default an operator overrides with their fabric's measured topology. |
| o | defined | symbol | pool | **PoolReuseVerdict (cachemeta gate)** - cachemeta.PoolReuseVerdict is the cross-tenant reuse trust GATE for a SHARED pool: it permits a tenant to attend a pooled cell another tenant wrote only when the cell is un-poisoned, declared shareable beyond its agent scope, adjudicated TaintTrusted, and its materialization key matches on every axis. |
| o | defined | symbol | pool | **PooledPrefillTokens (fleet-reuse compute)** - FleetReuseResult.PooledPrefillTokens (internal/cachemeta) is the prefill-token COMPUTE cost the chosen pool regime pays for one hot prefix shared by N tenants — one prefill under a reachable or fabric-shareable pool, N prefills when the tier is host-private. |
| o | defined | symbol | pool | **PooledResidentBytes (fleet-reuse capacity)** - FleetReuseResult.PooledResidentBytes (internal/cachemeta) is the resident-byte CAPACITY cost the chosen pool regime holds for one hot prefix shared by N tenants — ONE copy under a coherent fabric-shareable pool, N copies under a copy-only or host-private tier. |
| o | defined | symbol | pool | **WarmPoolFree (prewarm pollution gate)** - compute.PrewarmCandidate.WarmPoolFree is the pollution gate of the tool-latency prewarm admission decision: a bool that is true only when the lowest-eviction-priority warm KV pool has free capacity, so a WarmNow directive never displaces a demand session's resident prefix. |
| o | defined | symbol | pool | **SharedPool (fleet-benchmark catalog)** - FleetProfile.SharedPool (internal/turnbench) is a fleet-BENCHMARK knob: the number of DISTINCT shared reference reads the modeled agent fleet draws from (the shared catalog size), the parameter that makes the cross-agent dedup curve SATURATE as agent count rises. |
| o | defined | subsystem | pool | **cxlpooldemo (CXL pool demo)** - cmd/cxlpooldemo is a no-model, no-GPU command that proves the value of a SWITCH-POOLED multi-host shared memory tier (CXL.mem) by computing — purely over cachemeta tier/pool profiles — the three-way fleet economics (per-host private vs copy-only pool vs coherent CXL pool) and the cross-tenant trust gate. |
| o | defined | doc-term | render-materialize | **renderer (scorecard markdown projector)** - renderer is the pkg/scorecard term for the Jekyll-front-matter markdown projector half of a scorecard's shape (raw shape, control-pane JSON fold, markdown renderer, and the CLI), turning a scored corpus into a published doc. |
| o | defined | symbol | render-materialize | **renderChatMLTools (agent ChatML prompt)** - agent.renderChatMLTools renders the message history plus tool schemas as Qwen2.5 canonical <tool_call>/<tool_response> ChatML and terminates with an open assistant turn for generation, delegating to renderTranscriptTools; renderTranscript is the zero-tools, no-open-turn form used by the poison-eviction path. |
| o | defined | symbol | render-materialize | **RenderText (agentdemo transcript)** - agentdemo.Transcript.RenderText writes a plain-text walkthrough of an agent loop to a writer (the prompt, one line per step, the outcome), the human view of a demo transcript. |
| o | defined | symbol | render-materialize | **renderTurnDebugError (gateway failed-turn line)** - gateway Server.renderTurnDebugError emits one per-turn --debug-stats line for a FAILED turn (the trace, wire, error, and elapsed wall-clock), the failure-path counterpart that renderTurnDebugStats (which fires only on success) does not cover. |
| o | defined | symbol | render-materialize | **RenderContrast (sessionobs report)** - sessionobs.RenderContrast writes the value-vs-waste session-observation contrast report to a writer (value/waste counts, separability, and per-feature discriminators ranked worst-first). |
| o | defined | symbol | render-materialize | **renderSmoke* (swebench contract sections)** - The renderSmoke* family writes the shared markdown sections of a SWE-bench smoke contract (renderSmokeArmsTable the Arm/Harness/Model table, renderSmokeGatesTable the Gate/OK/Detail table, renderSmokeEvidenceLink the compare-evidence-link block, renderRequiredBeforeClaim the required-before-any-result-claim bullet list). |
| o | defined | symbol | render-materialize | **renderAutoDecision (compute target table)** - cmd/fak renderAutoDecision writes the `fak c --auto` ranked-decision table: cost-ordered compute targets, each with witnessed health/fit and an honestly-labeled quota stub, the winner, and the policy line. |
| o | defined | symbol | render-materialize | **RenderBoard (dojo leaderboard)** - dojo.RenderBoard produces the human cross-lever calibration leaderboard table (worst-first) from a dojo Board. |
| o | defined | symbol | render-materialize | **renderCommitResult (fak commit output)** - cmd/fak renderCommitResult prints the outcome of a safecommit run (the short SHA, path count, push suffix, and review), while renderPreview prints the `fak commit --preview` lint verdict (OK when the subject is witness-gradeable and bindable, else the blocking issues). |
| o | defined | symbol | render-materialize | **RenderDist (milestone ladder line)** - milestonereport.RenderDist renders the M0..M7 maturity-rung distribution as a compact one-liner ("M0:2 M1:0 ...") in ladder order, exported so the Slack milestone card renders the same ladder line. |
| o | defined | symbol | render-materialize | **renderGuardInfoPaneDryRun (guard --split preview)** - cmd/fak renderGuardInfoPaneDryRun resolves the `fak guard --split` plan and renders it WITHOUT spawning anything (the multiplexer, the 80/20 geometry, and the exact `fak info` pane command) so an operator can preview the split before launching it. |
| o | defined | symbol | render-materialize | **RenderIssueResult (maturity route card)** - maturity.RenderIssueResult is the human dry-run/live card for `fak maturity route`, summarizing the mode and the planned issue items. |
| o | defined | symbol | render-materialize | **RenderLedgerGapReport (nightrun)** - nightrun.RenderLedgerGapReport writes the benchmark-authority ledger-gap report to a writer: the authority's last-updated date, ledger totals, and the rows newer than or missing from the published benchmark surface. |
| o | defined | symbol | render-materialize | **RenderReadOut (support table)** - supportmaturityscore.RenderReadOut renders the support-maturity readout rows as a deterministic ASCII table for the human `fak support` view. |
| o | defined | symbol | render-materialize | **RenderTwoTrack (cache-value P&L)** - cachevaluereport.RenderTwoTrack renders the cache-value profit-and-loss two-track report side by side (the WITNESSED reuse track and its OBSERVED-dollar projection) with the verdict. |
| o | defined | symbol | render-materialize | **Materialize (ctxplan view)** - ctxplan.Materialize re-derives a budgeted View of the lossless context store each turn: PlanCells picks which spans fit the budget, the selected ones are paged in through the trust gate, and a faithfulness Witness reconciles rendered-vs-refused so every elided span stays recoverable. |
| o | defined | symbol | render-materialize | **MaterializeLayout (ctxplan)** - ctxplan.MaterializeLayout is the layout-aware peer of Materialize: it uses a four-area Layout to choose the bounded candidate set and per-area precision, then renders the selected exact spans through the same trust gate and witness reconciliation as the default path. |
| o | defined | symbol | render-materialize | **MaterializeVerdict (cachemeta gate)** - cachemeta.MaterializeVerdict is the central cache gate: given the runtime materialization view, the stored Entry, the requested key, and quality evidence, it returns a LookupVerdict deciding whether a cached prefix/KV span may be served (Hit) or must be refused (Miss). |
| o | defined | symbol | render-materialize | **Materializer (memview)** - memview.Materializer is the producer type whose MaterializeSnippet turns a (source page, offset, length) selector into a provenance-bound MemoryViewRecord plus an admission Verdict, filling the record's Body only when the source page is trusted (Allow) and leaving it nil on a tainted source (Quarantine). |
| o | defined | symbol | render-materialize | **materialize*Tensors (model arch)** - materializeFalconTensors and its per-architecture siblings rewrite a loaded source/GGUF tensor manifest into fak's canonical tensor names (aliasing and splitting source-format tensors) for one model family before inference. |
| o | defined | symbol | render-materialize | **materializeTensorAliases (model)** - materializeTensorAliases applies the config's explicit canonical->source tensor-name aliases, creating zero-copy canonical manifest rows before any fused-tensor split, so a loader can point a canonical fused tensor at a source-format fused name. |
| o | defined | symbol | render-materialize | **RenderTurn (ctxplan seam)** - RenderTurn (on the agent CtxViewPlanner / SessionPlanner) re-renders a turn's message history through the ctxplan seam — materializing a budgeted View and paging resident spans back as the agent message list — and returns its input unchanged when the seam is disabled. |
| o | defined | symbol | render-materialize | **RenderedTokens (ctxplan View)** - ctxplan View.RenderedTokens sums the token cost of every span actually paged into the fresh history — the realized resident size, which is <= budget by construction. |
| o | defined | metric | render-materialize | **RenderedBytes (memq stat)** - RenderedBytes (json rendered_bytes, in memq Result.Stats and contextq) is the stat counting the total bytes an OpRender / context query paged into context, accumulated across rendered cells. |
| o | defined | symbol | render-materialize | **OpRender (memq op)** - memq.OpRender is the query op that materializes the selected cell set into context as a read-only page-in through the trust gate, tallying RenderedBytes. |
| o | defined | symbol | render-materialize | **RenderTrace (agent)** - agent.RenderTrace renders the per-call agent trace log — each tool call's arm, turn, args, verdict, adjudicator, reason and disposition — as a human text report. |
| o | defined | symbol | render-materialize | **renderVerdict (gateway wire)** - gateway.renderVerdict projects a folded abi.Verdict (plus the admitted result's Meta) onto the wire WireVerdict shape — naming the kind, refusal reason, adjudicator, and disposition for the HTTP client. |
| o | defined | symbol | render-materialize | **renderTurnDebugStats (gateway)** - gateway Server.renderTurnDebugStats emits one per-turn debug key=val line (trace, wire, token counts, cache read/create, reset-health) when the --debug-stats sink is wired, and is a byte-identical no-op when it is off. |
| o | defined | symbol | render-materialize | **renderMetrics (gateway)** - gateway Server.renderMetrics renders the gateway's full Prometheus exposition text — the metric families scraped at /metrics. |
| o | defined | symbol | render-materialize | **RenderView (accounts registry)** - accounts.Registry.RenderView is a pure function projecting the account registry into the YAML text of a named view (dos/job), so `check` can diff on-disk bytes against a freshly rendered view and `sync` can write them. |
| o | defined | symbol | render-materialize | **RenderMarkdown (bench report)** - The RenderMarkdown family (benchscore, swebench, terminalbench, webbench, agenticbench, the browseraction action-mediation report, ...) renders a completed Report/Comparison struct of measured results into a Markdown document. |
| o | defined | symbol | render-materialize | **RenderOfficialRunContractMarkdown (contract)** - RenderOfficialRunContractMarkdown renders a benchmark's official-run CONTRACT to Markdown — the pre-run promise (target choice, evidence class, claim boundary, whether a result claim is allowed); siblings render the DeepSWE and opus-smoke SWE-bench contracts and the terminalbench rehearsal preflight. |
| o | defined | symbol | render-materialize | **renderTUI* (console pane)** - The renderTUI* family formats one fak console dashboard pane (loops/agent/garden/guard/issues/overview/sessions) from its typed report struct into a fixed-width terminal text view. |
| o | defined | symbol | render-materialize | **RenderCapabilities (nightrun)** - nightrun.RenderCapabilities writes the one-line box-capability summary (gpu/weights/datasets/net/creds) that prefixes every nightrun human view; siblings RenderNext and RenderLedger write the focused next-task answer and the durable collection ledger. |
| o | defined | symbol | render-materialize | **RenderIteration (guardrsi)** - guardrsi.RenderIteration formats one guard-verdict-RSI iteration (rows folded, verdict-quality delta, honesty holes, candidate lever, keep/revert rule) as text; sibling RenderScorecard formats the guard-RSI scorecard payload. |
| o | defined | symbol | render-materialize | **renderReason (repoguard)** - repoguard.renderReason builds the human refusal message when a destructive/write op targets a path outside the repo, listing each violating op->target with its resolved path and the remediation. |
| o | defined | concept | render-materialize | **render (verb)** - render is the repo-wide convention for a pure projection function that turns a typed value into a human/Markdown/wire/terminal text surface (e.g. the bare `func render` in loophealth and dispatchworker), without mutating its input. |
| o | defined | metric | score-debt | **per-scorecard *_debt integer** - Each scorecard emits one named debt integer counting its surface's unmet rungs — learning_debt (unwitnessed learning docs), conflation_debt (provenance honesty), growth_debt (silently-undefined coverage cells), loopindex_debt (loop stages not yet witnessed), maturity_debt (support-maturity ladder skips), support_maturity_debt, dogfood_debt, sessionobs_debt — read in delta folds via the DebtKey constant and the baseline/current bDebt/cDebt locals. |
| o | defined | subsystem | score-debt | **named scorecard surface (payload + baseline)** - These are concrete scorecard surfaces and their plumbing: learning_scorecard, code_quality_scorecard, and product_scorecard are distinct deterministic measurement tools, ScorecardPayload is the per-scorecard struct carrying corpus/KPIs/grade, and tools/scorecard_baseline.json is the pinned baseline the control-pane ratchet reds against. |
| o | defined | subsystem | score-debt | **agent-readiness scorecard** - The scorecard that measures how easy fak is for an AI agent (Claude Code, Codex, Cursor, an MCP client) to discover, adopt, and build on - missing entry points, harness configs, copy-pasteable first commands, per-agent recipes (tools/agent_readiness_scorecard.py). |
| o | defined | subsystem | score-debt | **persona-readiness scorecard** - The scorecard that measures whether fak serves its top human personas - the free-tier dev, the infra engineer, the researcher - each with the entry path they need (prebuilt binary, deploy guide, determinism witness) (tools/persona_readiness_scorecard.py). |
| o | defined | subsystem | score-debt | **doc-appeal scorecard** - The scorecard that measures whether a reader-facing doc reads like a person wrote it: em-dash flood, bold-emphasis flood, run-on sentences, walls of text, LLM-scaffolding phrases (tools/doc_appeal_scorecard.py). |
| o | defined | subsystem | score-debt | **docs scorecard** - The whole-corpus documentation scorecard: the 5-KPI doc-debt measure over the reachable doc set, the corpus analogue of the README freshness audit (tools/docs_scorecard.py). |
| o | defined | subsystem | score-debt | **observability scorecard** - The scorecard that measures observability debt across the metric, dashboard, alert, trace, log, proof, and DOS surfaces - what is and is not measured about the running system (tools/observability_scorecard.py). |
| o | defined | subsystem | score-debt | **steerability scorecard** - The scorecard that measures how steerable fak is - whether its behavior responds predictably to the configured knobs, flags, and policies (tools/steerability_scorecard.py, cmd/fak steering). |
| o | defined | subsystem | score-debt | **release-readiness scorecard** - The scorecard that measures whether the project is ready to cut a release: version state, release-notes draft, green gate, and the substantive-commit threshold the auto-cut decision reads (tools/release_readiness_scorecard.py). |
| o | defined | subsystem | score-debt | **seo/aeo scorecard** - The scorecard that measures search-engine and answer-engine optimization debt: structured-data sync, FAQ coverage, and the discoverability content checks over the public surfaces (tools/seo_aeo_scorecard.py). |
| o | defined | subsystem | score-debt | **bench-dx scorecard** - The scorecard that measures the developer experience of running benchmarks: whether the bench grid is discoverable, reproducible, and well-documented (tools/bench_dx_scorecard.py). |
| o | defined | subsystem | score-debt | **build scorecard** - The scorecard that grades the CUDA build/dev process health (standing author, build, validate, gate, onboard) folded into the guard-RSI and cuda-dev surfaces (internal/guardrsi buildScorecard). |
| o | defined | metric | score-debt | **hygiene-debt** - The single debt integer the repo-hygiene scorecard folds to: noisy artifacts, placement drift, generated junk across the tree. |
| o | defined | metric | score-debt | **health-debt** - The debt integer for fleet/service health defects: incident, stale, and deferred surfaces the watchdog and health-beat report fold to a single number. |
| o | defined | metric | score-debt | **ui-quality-debt** - The debt integer the ui-quality scorecard folds to: TUI render defects measured over the pane render source (internal/uiquality), e.g. rune-safety and cell-alignment KPIs. |
| o | defined | metric | score-debt | **milestone-debt** - The debt integer the milestone report folds to: the gap between the maturity climb plus epic roadmap and where the milestones should stand. |
| o | defined | subsystem | session-runtime | **sessionobs (observability scorer)** - internal/sessionobs is the stdlib-only RSI scorecard that grades how far our own coding-session data has climbed the capture->structure->link->aggregate->learn ladder, the value-side complement to the cost-only tools/session_audit.py; its `fak sessions learn` rung is the registered loop consumer that reads the committed corpus. |
| o | defined | metric | session-runtime | **SessionObsDebt (ladder-rung debt)** - sessionobs.Corpus.SessionObsDebt is the headline integer the session-observability scorecard emits: the count of HARD ladder rungs (capture/structure/link/aggregate/learn) not yet built, retired only by building the real rung never by weakening a check. |
| o | defined | config | session-runtime | **taskscheduler (Windows cron target)** - taskscheduler is the `fak cron emit --target taskscheduler` OS-scheduler target that projects a registered fak loop into a Windows Task Scheduler `Register-ScheduledTask` snippet (alongside launchd and systemd), so a job survives reboot; the same family's NewNativeScheduler is an unrelated decode-engine constructor. |
| o | defined | metric | session-runtime | **TotalSessions (cache-value session counts)** - TotalSessions, MultiTurnSessions and SingleTurnSessions are the cachevalueledger/cachevaluereport roll-up counters splitting the observed cache-value corpus by turn count, alongside the gateway's LiveSessions tally, the fleet's FleetSessions/tools snapshot, the resetHealth reaper bound maxResetHealthSessions, the dojo cross_session_warm_hit_rate posture metric, and the cachewitness honesty-fence SingleSessionMarginalX. |
| o | defined | symbol | session-runtime | **requireGLMDsaSession (model fence)** - requireGLMDsaSession is a generated model-layer fence (sibling of requirePreNorm) asserting that a model.Session uses the GLM DSA attention path, recorded in the regenerated snapshot the harness commits. |
| o | defined | symbol | session-runtime | **WithSessionGate (agent run option)** - agent.WithSessionGate is the RunOption that threads a live session gate plus its trace into the native agent turn loop (loop_session.go), so each turn is admitted/throttled and can drain operator steers at its boundary like a served request. |
| o | defined | config | session-runtime | **FakSessionReset (checkpoint sibling task)** - FakSessionReset is a Windows Task Scheduler task-name label in the fak ops registration scripts, the reset sibling of the FakSessionCheckpoint scheduled task that keeps headless session state fresh. |
| o | defined | symbol | session-runtime | **loop_session.go (agent session seam)** - loop_session.go is the agent package's session-control seam for the turn loop: it threads the session gate (WithSessionGate/gateTurn), the operator steer splice (drainSteer), and per-tool-call routing into agent.Run's native loop. |
| o | defined | symbol | session-runtime | **SessionType (cache-value workload tag)** - SessionType is the cachevaluereport per-observation workload label (run | guard | serve) that splits the cache-value roll-up, rendered as the SessionTypeMix histogram in the cachevalue review. |
| o | defined | symbol | session-runtime | **SlotFreed (gateway wire event)** - gateway.SlotFreed is the wire-neutral struct the scheduler's SlotEvent crosses into the gateway as (TraceID, Cause, Rev), projected by slotEventToSlotFreed and consumed by Server.ReclaimKVOnSlotFreed to drive real KV reclamation. |
| o | defined | config | session-runtime | **FakSessionCheckpoint (resume packet task)** - FakSessionCheckpoint is the Windows Task Scheduler task name registered by tools/register_session_checkpoint.ps1 that runs the session-checkpoint job (the verified resumable packet sourced from witnessed state, #636) on a cadence. |
| o | defined | subsystem | session-runtime | **sessionbench (value-stack bench)** - cmd/sessionbench is the Go benchmark command that measures the net value-add of fak's fused agent kernel over a synthetic multi-agent, multi-turn session workload (its prefillTokens A/B/C formula). |
| o | defined | symbol | session-runtime | **DurabilitySession (durability tier)** - DurabilitySession is the ctxplan/ctxmmu durability-tier constant ("session") that marks a stored context span as true only for the current session's lifetime. |
| o | defined | symbol | session-runtime | **BatchSession (batched decode)** - model.BatchSession decodes B independent user sequences in lockstep over one shared weight stream (continuous-batching decode), built via NewBatchSession. |
| o | defined | symbol | session-runtime | **decideSession (admit hook)** - decideSession is the host-injected request-boundary hook that applies session.Table.Decide so each served model request honors run-state, turn/token/context budget, and pace before the upstream call runs. |
| o | defined | symbol | session-runtime | **observeSession (read hook)** - observeSession is the read side of the /v1/fak/session control surface, returning one served session's current DRIVE state (run-state, budget, pace) without mutating the table. |
| o | defined | symbol | session-runtime | **debitSession (usage hook)** - debitSession is the host hook that records a served request's post-response token usage (output + context) into the drive table so the next Decide sees budget exhaustion. |
| o | defined | symbol | session-runtime | **NewBackendSession (HAL session)** - model.NewBackendSession starts a single-user model.Session whose per-token forward path runs through an injected compute HAL backend (CUDA/Vulkan/Metal device). |
| o | defined | symbol | session-runtime | **servedSessionTurn (gateway turn record)** - servedSessionTurn is the gateway's internal per-request record (traceID, resolved SessionState, maxTokens, minGapMs) produced when the session gate admits one proxied model request. |
| o | defined | symbol | session-runtime | **beginServedSessionTurn (gateway admit)** - Server.beginServedSessionTurn applies the live session gate to one proxied model request, calling the wired DecideSession (or the ObserveSession fallback) and enforcing the pace min-gap before the turn runs. |
| o | defined | symbol | session-runtime | **debitServedSessionTurn (gateway debit)** - Server.debitServedSessionTurn reports a just-served model request's provider usage back through the injected DebitSession hook so output/context budgets are debited. |
| o | defined | symbol | session-runtime | **resetServedSessionOnBudget (reset hook)** - resetServedSessionOnBudget is the host-owned ResetOnBudgetFunc the gateway calls after a context-budget drain to distill a carryover seed, re-arm the continuation trace with a fresh context budget, and let the live request continue transparently. |
| o | defined | symbol | session-runtime | **steerSession (steer hook)** - steerSession enqueues an operator steer onto the process-global a2achan bus (keyed by the session trace) so a running detached session can splice the input at its next turn boundary. |
| o | defined | symbol | session-runtime | **controlSession (write hook)** - controlSession is the write side of /v1/fak/session, applying one DRIVE control verb (run|budget|pace|priority) to a live session's state with optional if_rev optimistic-concurrency. |
| o | defined | symbol | session-runtime | **IngestSession (cdb)** - cdb.IngestSession parses a Claude Code session JSONL transcript at a path into a recall.Recorder, applying the ctxmmu write-time seal/quarantine decision per tool result. |
| o | defined | symbol | session-runtime | **SessionFromPrefix (prefix clone)** - model.SessionFromPrefix starts a model.Session whose KV cache is an independent clone of an already-computed prefix cache, so a known prefix can be spliced into a new session before prefilling a suffix. |
| o | defined | symbol | session-runtime | **SessionListResponse (wire)** - gateway.SessionListResponse is the wire result of GET /v1/fak/sessions — a snapshot array of every live session's DRIVE state plus a Count. |
| o | defined | symbol | session-runtime | **sessionQ4KKernel (decode matvec)** - sessionQ4KKernel (with siblings sessionQ8Kernel and sessionQ4Kernel) is an allocation-light per-token decode matvec kernel that wraps a *model.Session and dispatches projections by resident quant format (Q4_K / Q8 / Q4_0), reusing the session's activation buffer. |
| o | defined | cli-verb | session-runtime | **cmdSession (CLI verb)** - cmdSession is the `fak session` CLI entry point, delegating to its testable core runSession to read and POST DRIVE-state controls to a gateway's session REST surface. |
| o | defined | symbol | session-runtime | **sessionClient (CLI HTTP client)** - sessionClient is the cmd/fak HTTP client struct (base URL, key, http.Client) that the session/ps/signal/tui commands use to call the gateway's session observe/list/control endpoints. |
| o | defined | symbol | session-runtime | **SessionResetDirective (handoff)** - gateway.SessionResetDirective is the machine-readable handoff a supervisor receives when a served session's budget is exhausted, carrying the continuation id and carryover so a fresh window can resume. |
| o | defined | config | session-runtime | **defaultSessionAddr (CLI target)** - defaultSessionAddr returns the gateway base URL the cmd/fak session/ps/signal/tui commands target — $FAK_ADDR when set, otherwise the built-in localhost default. |
| o | defined | symbol | session-runtime | **SessionBudget (wire)** - gateway.SessionBudget is the wire form of internal/session.Budget, carrying TurnsLeft, TokensLeft, and ContextTokensLeft for one session. |
| o | defined | symbol | session-runtime | **SessionPace (wire)** - gateway.SessionPace is the wire form of internal/session.Pace, carrying MaxTokensPerTurn and MinTurnGapMs (zero on either axis means unset). |
| o | defined | symbol | session-runtime | **writeSessionRefusal (409 emitter)** - writeSessionRefusal emits the HTTP 409 a proxied request receives when an operator has held, paused, or stopped a session, embedding the SessionState reason and any reset directive. |
| o | defined | symbol | session-runtime | **emitSessionJSON (CLI printer)** - emitSessionJSON is the cmd/fak helper that marshals a session value (state, list, or ack) to JSON on stdout and returns the process exit code for the --json output mode. |
| o | defined | subsystem | session-runtime | **NativeScheduler (modelengine)** - modelengine.NativeScheduler is the continuous-batching-shaped LifecycleEngine stub whose single scheduler loop owns one model.BatchSession and advances all admitted lanes in lockstep. |
| o | defined | symbol | session-runtime | **OnSlotFreed (scheduler callback)** - session.Scheduler.OnSlotFreed registers the single host callback the scheduler invokes once per slot-freed SlotEvent when a session transitions to a slot-releasing run-state. |
| o | defined | symbol | session-runtime | **ReclaimKVOnSlotFreed (gateway KV reclaim)** - Server.ReclaimKVOnSlotFreed is the gateway's consumer of a scheduler SlotFreed event that, on a terminal cause (draining/stopped), drives the injected KV reclaimer to free that session's real KV-cache pages. |
| o | defined | symbol | session-runtime | **PublishSessionRevision (change feed)** - Server.PublishSessionRevision records one drive-state revision onto the gateway's session change feed (#630) so /v1/fak/session/changes subscribers can drain DRIVE-state updates. |
| o | defined | symbol | session-runtime | **serveSessions (drive table)** - serveSessions is the process-local, TraceID-keyed, bounded-LRU session.Table holding every served session's DRIVE state (run-state/budget/priority/pace), shared by the gateway session routes and any in-process agent loop. |
| o | defined | symbol | session-runtime | **sessionAdmits (proxy admission gate)** - Server.sessionAdmits is the gateway's fallback proxy admission gate that reports whether a proxied request may proceed under the operator-controlled DRIVE run-state, failing OPEN when no ObserveSession hook is wired. |
| o | defined | symbol | session-runtime | **SlotCause (scheduler reason)** - session.SlotCause is the closed enum naming WHY a scheduling slot freed (budget-exhausted | paused | draining | stopped), carried on a SlotEvent and rendered as a lowercase token. |
| o | defined | symbol | session-runtime | **toGatewaySessionState (projection)** - toGatewaySessionState projects an internal/session.State value into the gateway's wire SessionState DTO so cmd/fak can publish DRIVE state without the gateway importing internal/session. |
| o | defined | symbol | session-runtime | **WithSessionTable (run option)** - agent.WithSessionTable is the RunOption that threads a per-session DRIVE-state session.Table plus the run's trace id into the agent loop so each turn honors the same budget/pace/run-state as a served request. |
| o | defined | symbol | session-runtime | **handleFakSession (HTTP route)** - Server.handleFakSession is the gateway HTTP handler for /v1/fak/session/{id} — the read-write DRIVE-state control route that fans GET to observeSession and POST verbs to controlSession/steerSession. |
| o | defined | symbol | session-runtime | **Budget** - A session's remaining work allotment across three independent axes: turns (round-trips), output tokens, and context tokens. |
| o | defined | symbol | session-runtime | **Pace** - The per-turn throttle: max output tokens and minimum gap between turns, applied cooperatively without pausing the session. |
| o | defined | symbol | session-runtime | **RunState** - A served session's lifecycle position in a small total state machine: Running, Throttled, Paused, Draining, or Stopped. |
| o | defined | symbol | session-runtime | **SessionID** - The stable identity key for a session (its TraceID), constant across all of the session's turns. |
| o | defined | symbol | session-runtime | **NewSession** - The constructor that admits a fresh session into the table with its initial drive state. |
| o | defined | symbol | session-runtime | **SessionTurn** - One accounted served round-trip bound to a session: the begin / debit / served lifecycle of a single turn. |
| o | defined | symbol | session-runtime | **SessionUsage** - Per-session token and cost accounting rolled up across the session's turns. |
| o | defined | symbol | session-runtime | **SessionControlRequest** - An external steer directive against a live session: pause / resume / priority / pace change. |
| o | defined | symbol | session-runtime | **SessionReset** - A directive to clear a session's drive state back to a clean baseline without removing it from the pool. |
| o | defined | symbol | session-runtime | **ListSessions** - The read query that returns a snapshot of all live sessions in the table. |
| o | defined | concept | support-maturity | **SupportMaturity Rung (M0-M7 ladder)** - supportmaturity.Rung is the uint8-backed closed M0-M7 support-maturity ladder type (M0 unsupported through M7 beyond-SOTA, with M6Parity the SOTA-local parity rung), and FromSupport lowers a covmatrix Support value onto that ladder (UNDEFINED/FENCED/PROOF-PATH/SUPPORTED to M0/M1/M3/M4). |
| o | defined | metric | support-maturity | **MaturityScore (cadence maturity fold)** - cadencereport MaturityScore is the LedgerRow integer rating of the feature-lifecycle scorecard, produced by CollectMaturity (which builds and converts the Go-native maturity scorecard in-process) and merged into the cadence envelope by FoldWithMaturity. |
| o | defined | symbol | support-maturity | **ExactSpanSupported (engine evict capability)** - ExactSpanSupported (enginecache Result field, set by SupportsExactSpan) reports whether a documented serving engine or KV pool can evict exactly the named K/V span instead of resetting the whole prefix cache, the same capability bit SupportsRaw exposes for a paged KV pool that carries the Kraw plane. |
| o | defined | symbol | witness-proof | **loopmgr witnessed run-status set** - The loop/bench witnessed run-status family: loopmgr.StatusWitnessRefused ("witness_refused") and StatusWitnessUnavailable ("witness_unavailable"), bench/loopgate VerdictWitnessed/OutcomeWitnessed ("witnessed") and its witnessed_done promotion, callavoid's WitnessedRedirect and its WitnessedEmpty count, and loopindex's WitnessedIndex health score. |
| o | defined | symbol | witness-proof | **unwitnessed-claim reason set** - The unwitnessed-claim deny/re-arm reason family: loopgate.ReasonDoneUnwitnessed ("LOOP_DONE_UNWITNESSED", the re-arm reason when a done claim has no witness, as adjudicated for a claim-unwitnessed turn) and the proposed context-safety SAFETY_UNWITNESSED DOS refusal token for a rendered number with no tamper-evident source. |
| o | defined | symbol | witness-proof | **ReviewRefute (scout review verdict)** - modelroute.ReviewRefute is the scout-review verdict value "refute" returned when an opt-in pre-commit review rejects a diff; safecommit raises it to the ReasonReviewRefuted ("REVIEW_REFUTED") refusal that blocks the commit before it lands. |
| o | defined | symbol | witness-proof | **WitnessFor (support-maturity prover)** - supportmaturity.WitnessFor returns the exact non-author WitnessKind that must PROVE a given support-maturity rung, the binding the promotion check enforces (the evidence kind must be precisely the witness WitnessFor names). |
| o | defined | symbol | witness-proof | **EventWitness (loop ledger event kind)** - loopmgr.EventWitness is the loop-ledger event KIND carrying a run's external verdict (witnessed_done / witness_refused / witness_unavailable), the row that supplies the independent done-evidence the loopverify corpus folds beside each self-reported EventEnd. |
| o | defined | subsystem | witness-proof | **cachewitness (KV-prefix value seam)** - internal/cachewitness is the observation seam that folds the WITNESSED kv_prefix metric family (KVPrefixWitness.ReuseRatio over fak_gateway_kv_prefix_reused_tokens_total) into a provenance-labeled Record, keeping WITNESSED reuse strictly distinct from OBSERVED provider cache_read and exposing the honesty-fence SingleSessionMarginalX. |
| o | defined | symbol | witness-proof | **WitnessResult (loopgate evidence summary)** - loopgate.WitnessResult is the witness adapter's evidence summary struct (Outcome, Reason, Detail, RawVerdict, Rung) that Adjudicate consumes to accept a done claim only on OutcomeWitnessed, parsed from the dos commit-audit/verify JSON. |
| o | defined | symbol | witness-proof | **witnessPrefix (blob-hash label)** - syspromptmmu.witnessPrefix is the constant "blob-sha256:" that labels a syspromptmmu Witness string as a content-blob hash (not a git object id), so a system-prompt span's admitting witness is recognizable as a content digest. |
| o | defined | doc-term | witness-proof | **TestPrefixReuseFanoutWitness (fanbench soundness proof)** - TestPrefixReuseFanoutWitness is the cmd/fanbench soundness test that grounds the fan-out prefix-reuse GEOMETRY claim: it prefills the master-goal prefix once and proves N cloned sub-agents are bit-identical to an independent full prefill (max|delta|=0). |
| o | defined | symbol | witness-proof | **TallyFromCountersWitnessed (realized-deny fold)** - callavoid.TallyFromCountersWitnessed is TallyFromCounters with a set of WITNESSED productive denies (each a WitnessedRedirect carrying its enumerated variant set), netting witnessed denies so each deny is counted exactly once and only a non-forgeable, deduplicated fan-out is credited into the graded headline. |
| o | defined | symbol | witness-proof | **VerdictRequireWitness (abi verdict)** - abi.VerdictRequireWitness is the kernel verdict kind that leaves a gated call PENDING an independent read-back, so the kernel must corroborate the caller's claimed effect (carried in the WitnessPayload) before the call may dispatch. |
| o | defined | symbol | witness-proof | **ReasonUnwitnessed (deny reason)** - abi.ReasonUnwitnessed is the deny reason-code the kernel attaches when a require-witness gate found no corroboration, so the fail-closed default turns the pending verdict into a DENY (also surfaced as looprecover's unwitnessed disposition). |
| o | defined | symbol | witness-proof | **WitnessPayload (verdict claim carrier)** - abi.WitnessPayload is the typed bounded-disclosure verdict payload struct{Claim string} that an adjudicator attaches to a RequireWitness or Deny verdict to carry the single claim string the kernel must corroborate. |
| o | defined | concept | witness-proof | **refute (revocation trigger)** - refute is the action of calling vdso.Revoke(witness) on the integrity/coherence bus to mark a previously-trusted world-state witness as contradicted, stranding every cache entry admitted under it. |
| o | defined | symbol | witness-proof | **ProofRefuted (callavoid status)** - callavoid.ProofRefuted is the two-valued proof-status value 'REFUTED' meaning a cost-benefit proof concluded that avoidance/memoization does not pay (single-use, too-volatile, or validation as costly as the call). |
| o | defined | symbol | witness-proof | **WitnessRecord (taskmgr evidence)** - taskmgr.WitnessRecord is the evidence-backed verdict struct a Witness attaches BESIDE a task/step's claimed State (VerifiedState plus source and evidence refs), so a snapshot holds both 'process says done' and 'a witness has/has not confirmed it'. |
| o | defined | symbol | witness-proof | **WitnessConfirmed (witness outcome)** - abi.WitnessConfirmed is the WitnessOutcome value meaning a resolver INDEPENDENTLY CORROBORATED the claimed effect from evidence the agent did not author, which opens the require-witness gate. |
| o | defined | symbol | witness-proof | **WitnessRefuted (witness outcome)** - abi.WitnessRefuted is the WitnessOutcome value meaning a resolver found evidence that CONTRADICTS the claimed effect (the agent's claim was false), keeping the require-witness gate closed. |
| o | defined | symbol | witness-proof | **WitnessAbstain (witness outcome)** - abi.WitnessAbstain is the zero-value WitnessOutcome meaning the resolver had NO evidence either way (fail-to-abstain), e.g. an unrecognized claim or git unavailable, which the kernel's fail-closed default then turns into a deny. |
| o | defined | symbol | witness-proof | **defaultWitnessOf (vdso extractor)** - vdso.defaultWitnessOf is the default extractor that derives the external world-state witness string a call/result was admitted under (from the call/result meta), used by the coherence bus when no per-tool adapter is registered. |
| o | defined | symbol | witness-proof | **resolveWitness (kernel gate driver)** - kernel.resolveWitness drives the require-witness gate: on a RequireWitness verdict it asks every registered abi.WitnessResolver to corroborate the claim and folds their WitnessOutcomes into a final allow/deny. |
| o | defined | symbol | witness-proof | **ShapeGLMTurnSegmentWitnessed (coherence shaper)** - cachemeta.ShapeGLMTurnSegmentWitnessed is the simplest live-path coherence shaper: given a turn's prompt segments and a revoked(witness) predicate, it emits the prefix-break directive that severs the provider prefix at the first refuted span. |
| o | defined | symbol | witness-proof | **StatusWitnessedDone (loop run status)** - loopmgr.StatusWitnessedDone is the loop run-status 'witnessed_done' meaning an independent witness event confirmed the run's claimed completion (carrying evidence refs), promoting it above claimed_done. |
| o | defined | symbol | witness-proof | **SubscribeRevocations (vdso observer seam)** - vdso.SubscribeRevocations registers an observer callback that fires on every refutation (Revocation) published to the integrity bus and returns a cancel func, never firing on the read hot path. |
| o | defined | symbol | witness-proof | **WitnessEntry (session-image keep-bit)** - sessionimage.WitnessEntry binds one effect's keep-bit (a taskmgr.WitnessRecord) to a stable EffectID inside a persisted/restored session image, so a rehydrated session knows which effects were witnessed. |
| o | defined | symbol | witness-proof | **WitnessFunc (vdso witness adapter)** - vdso.WitnessFunc is a per-tool adapter func(c *ToolCall, r *Result) string registered via RegisterWitness that extracts the external world-state witness a specific tool's result was admitted under, overriding the default extraction. |
| o | defined | metric | witness-proof | **WitnessGaps (TUI counter)** - WitnessGaps is the TUI loop-overview counter tallying runs that ended or claimed done but were never witnessed — the per-report aggregate of the unwitnessed gap, weighted into the attention score. |
| o | defined | symbol | witness-proof | **StatusWitnessRefused (loop run status)** - loopmgr.StatusWitnessRefused is the loop run-status 'witness_refused' (and its WitnessRefused counter) meaning a witness RAN and the evidence contradicted the run's claimed completion. |
| o | defined | metric | witness-proof | **MissWitnessRevoked (vdso cache-miss)** - vdso.MissWitnessRevoked is the cache-miss reason 'WITNESS_REVOKED' counted when a cached entry was admitted under a now-refuted external witness and therefore fails closed instead of serving stale bytes. |
| o | defined | symbol | witness-proof | **VerifiedUnavailable (witness unavailable)** - taskmgr.VerifiedUnavailable (and loopmgr.StatusWitnessUnavailable) is the state where a witness was ASKED but could not read the effect back — no network, a missing ref — so the claim is neither confirmed nor refused and must not downgrade to claimed-done. |
| o | defined | doc-term | witness-proof | **dgxGlmGpuWitness (CUDA GPU proof)** - dgxGlmGpuWitness is the on-GPU server CUDA GPU correctness witness for the GLM-MoE-DSA backend forward (TestCUDAGLMMoeDsaBackendForward run via tools/dgx_glm_gpu_witness.sh), invoked because the win32 build host cannot execute the CUDA path. |
| o | defined | symbol | witness-proof | **WitnessOutcome** - The result of claim corroboration: Confirmed (evidence supports it), Refuted (evidence contradicts it), or Abstain (no definitive evidence). |
| o | defined | symbol | witness-proof | **TrustEpoch** - A monotonically-increasing integrity clock that increments with each witness refutation, dual to WorldVersion (the consistency clock). |

## Per-KPI (disambiguation-debt = clarity of the rows that exist)

| Group | KPI | Score | Debt | Detail |
|---|---|---:|:--:|---|
| honesty | `kind_grounding_soft` | 60 | 0 | 16 kind/grounding mismatch |
| honesty | `hierarchy_soft` | 76 | 0 | 4 hierarchy issue(s) |
| well-formed | `well_formed` | 100 | 0 | all 683 rows well-formed |
| distinctness | `canonical_unique` | 100 | 0 | every concept has a unique canonical name |
| distinctness | `defined` | 100 | 0 | every concept has a definition |
| distinctness | `disambiguated` | 100 | 0 | every confusable concept names what it is NOT |
| grounded | `grounded` | 100 | 0 | every concept's grounding token appears in the tree |
| grounded | `anchored` | 100 | 0 | every crystal concept's distinction is anchored on disk |
| honesty | `clarity_consistent` | 100 | 0 | every verdict matches its evidence |

## Coverage by family (how much of each confusable space is positioned)

| Family | Positioned | Discovered | Unpositioned |
|---|---:|---:|---:|
| plan | 132 | 141 | 9 |
| render-materialize | 64 | 72 | 8 |
| session-runtime | 75 | 83 | 8 |
| score-debt | 33 | 39 | 6 |
| guard-gate | 89 | 93 | 4 |
| pool | 18 | 21 | 3 |
| support-maturity | 15 | 18 | 3 |
| cache | 95 | 96 | 1 |
| policy-capability | 63 | 64 | 1 |
| witness-proof | 49 | 50 | 1 |
| attention | 57 | 57 | 0 |
| context-ctx | 69 | 69 | 0 |
| cross-cluster | 0 | 0 | 0 |
| decision | 15 | 15 | 0 |
| evict | 21 | 21 | 0 |
| gateway-engine | 114 | 114 | 0 |
| layout | 9 | 9 | 0 |

