# DOS kernel runtime state (regenerated on every tool call)
.dos/
**/.dos/

# Slack control bridge runtime state (regenerated on each control operation)
fak/.slack_control_*

# Compiled build artifacts (regenerable from source via `go build`)
*.exe

# Cross-platform node-benchmark build dir (tools/fak_node_bench.sh; binaries have no
# .exe extension on macOS/Linux). (Node-bench result outputs are ignored below per the
# operator-requested regenerable-output rule.)
fak/.benchbin/

# Built fak binary dropped by run_local_model.sh / dogfood-claude.sh (regenerable via
# `go build ./cmd/fak`). The scripts are tracked; the binary they build is not.
tools/.bin/

# Python bytecode cache (created when tools/*.py import each other)
__pycache__/
*.pyc

# Regenerable operator snapshots written by the /plan-audit skill (re-run anytime)
docs/_audits/

# Raw session-status / working-note `.txt` drops under docs/benchmarks are transient
# operator notes (a session's live blockers, internal paths, bring-up state) — NOT the
# curated public results docs, which are ALL `.md`. By default these belong in the
# private notes repo (../fak-private), the same as a session's brainstorm/audit notes.
# Ignoring the `.txt` class here makes that the default: a stray status note can never be
# `git add`-ed into this public tree by accident (same private-by-default guard pattern
# as the bench-node run dirs further below). Curated `.md` benchmark docs stay tracked.
docs/benchmarks/*.txt

# Local rendered exports; source markdown is tracked.
docs/explainers/kv-cache-agentic-context.html
docs/explainers/kv-cache-agentic-context.pdf

# Regenerable run-output drops that otherwise re-leak into `git status` every session
# on the shared trunk (a trajectory-audit finding): process stdout/stderr redirects at
# the repo root, the empty experiments run-scaffold, and the industry-scorecard cadence
# output (written by tools/industry_freshness_cadence.py). The SCRIPTS are tracked; the
# state they emit is not — same private-by-default guard as the bench-node run dirs below.
# Root-level *_out.txt / *_err.txt are shell stdout/stderr redirects from ad-hoc
# `fak serve`/`scout`/probe runs (serve_*, scout_*, …); ignore the class so a new probe
# name never re-leaks. Tracked .txt elsewhere is unaffected (these are anchored to root).
/*_out.txt
/*_err.txt
experiments/registry.jsonl
docs/industry-scorecard/cadence-output/

# Fleet session/watchdog runtime state — machine-local generated snapshots, logs and
# PID/lease tracking (timestamps, live PIDs, account throttle windows). Regenerated on
# every supervisor/resume-watchdog tick; the SCRIPTS under tools/ are tracked, the state
# they write is not.
tools/_registry/
tools/_watchdog/
tools/_walltime.*

# Local live-dogfood scratch state: try-it PID files, logs, and one-off console proof
# artifacts. Regenerated per operator session.
.dogfood/

# Scratch / temp leaks that occasionally land in the tree when a tool writes to a relative
# path instead of an absolute temp dir (e.g. a flattened C...scratchpad...json at the repo
# root, or a *tmp working dir). Private-by-default so they can never be `git add`-ed; the
# FILE_ADMISSION gate is the commit-time backstop for anything that slips past these globs.
*scratchpad*
**/rmverifytmp/
**/*verifytmp/

# Regen / run-artifact leaks that accumulate in the shared dogfood tree. None of these are
# inputs to a build — they are per-session scratch (.regen-scratch/ holds regenerated copies
# of the top-level docs), DOS run telemetry (dos.runs/*.json), a one-off lane-isolation
# helper, or the .run.{err,out,log} sidecars that `fak sweep` already classifies as junk.
.regen-scratch/
dos.runs/
/.split_reconstruct.py
*.run.err
*.run.out
*.run.log

# Mermaid render toolchain for the visuals deck (regenerate via visuals/render.sh)
visuals/node_modules/
visuals/.render-scratch/

# Single-writer release lock — machine-local critical-section state written by
# tools/release_lock.py (holder owner/pid/host/TTL). Regenerated per release; the
# SCRIPT under tools/ is tracked, the lock it writes is not.
.release.lock

# CUDA backend build artifacts (fak/internal/compute, -tags cuda). The .cu/.h/.go/.sh
# SOURCES are tracked; the nvcc-compiled object + static lib are regenerated by
# build_cuda.sh and never committed.
internal/compute/*.o
internal/compute/*.a

# Vulkan backend build artifacts (internal/compute, -tags vulkan). The .comp/.cpp/.h/.go
# SOURCES are tracked; SPIR-V modules are regenerated by build_vulkan.ps1.
internal/compute/spirv/

# Editor-local settings
.vscode/
.codex/
# .claude/ holds the COMMITTED project skill pack (skills/, project.yaml) — do NOT ignore the
# whole dir or it silently drops tracked infrastructure. Ignore only machine-local settings.
.claude/settings.local.json
.claude/*.local.json

# Python test cache (regenerable)
.pytest_cache/
**/.pytest_cache/

# Ruff linter cache (regenerable; written by ruff on lint, carries a CACHEDIR.TAG)
.ruff_cache/
**/.ruff_cache/

# Local Go build/test caches sometimes written under fak/ by WSL/PowerShell
# test runners. Regenerable; never release content.
.gobuild-tmp/
fak/.gocache/
fak/.gotmp/
/coverage

# Scratch test-runner logs dropped into fak/ by WSL/PowerShell test runs
# (test.sh, pre-commit, glm-oracle export). Regenerable; some carry the
# private codename, so never commit. Hidden dotfiles by convention.
fak/.*.log

# Local/private configuration and credentials. Keep committed examples/template
# files public-safe; put real hostnames, tailnet details, and credentials in
# ignored local files.
.env
.env.*
!.env.example
*.local.json
*.local.yaml
*.local.yml
*.local.ps1
*.local.sh
!*.local.ps1.example
!*.local.sh.example
*.pem
*.key
*.p12
*.pfx
# GCP / cloud service-account JSON keys + any secrets dir — never tracked. The
# *.sa.json convention + a secrets/ dir mirror tools/create_gcp_admin_sa.sh (and
# the private repo); check_committed_files.py is the fail-closed commit-time block.
secrets/
**/secrets/
*.sa.json
*-sa-key.json
*-gcp-key.json
tools/fleet_endpoints.json
tools/fleet_endpoints.local.json
# Real bench-node registry (tailnet IPs / ssh users / host keys). The committed
# bench_nodes.example.json is the public-safe template; this one is machine-local.
tools/bench_nodes.json

# Local handoff bundles / archives
*.tgz
*.tar.gz

# macOS Finder metadata
.DS_Store
**/.DS_Store

# Regenerable benchmark outputs — ignored per operator request (2026-06-17) to keep
# `git status` quiet. NOTE: this REVERSES the repo's prior convention of tracking these
# (model-baseline/ and fleet/eraser/ already have committed csv/json; fleet-nodes/ was
# documented as tracked above). Already-committed files under these paths stay tracked
# unless deliberately removed, so only NEW outputs are hidden by these rules.
fak/experiments/fleet-nodes/
fak/experiments/dgx/
experiments/dgx/
# DGX benchmark runs registered into the catalog by tools/bench_slack.py
# (historical register_dgx_run, machine_id=dgx*) land here. The GPU server lab
# subsystem is PRIVATE-ONLY, so keep these run dirs untracked: a run registered in
# ANY clone (public or private) is then private by default and can never be
# `git add`-ed into either repo by accident. Keep both layouts: the private
# superrepo nests the module under fak/, while this public checkout is root-hoisted.
fak/experiments/benchmark/runs/by-machine/dgx*/
experiments/benchmark/runs/by-machine/dgx*/
# `fak nightrun --apply` captures each task's raw stdout under experiments/nightrun/<box>/.
# Those per-box dirs are LOCAL evidence only: regenerable, low-signal (mostly failure logs),
# and one carries a raw os.Hostname() box dir (pre-#970) that must never reach the public tree.
# The durable record is docs/nightrun/collected.jsonl; the operator overlay
# experiments/nightrun/backlog.json stays tracked (a shareable input, not an artifact).
# docs/nightrun/cache-value.jsonl is a per-run scratch sibling of collected.jsonl —
# regenerated each nightrun, not the durable ledger, so it stays out of the tree.
fak/experiments/nightrun/*/
experiments/nightrun/*/
docs/nightrun/cache-value.jsonl
# DGX Slack control-bridge source is PRIVATE-ONLY. Its home is the private repo
# fak-private (tools/dgxbridge/); fleet is the sunset archive. tools/check_committed_files.py
# already REFUSES any cmd|internal/*dgx*/ path at commit (this is exactly how cmd/dgxbridge +
# internal/dgxbridge leaked once); these ignore rules also keep a stray working copy out of
# `git status` so an auto-ship never tries to add it. Un-prefixed to match this repo's
# module-at-root layout — the fak/-prefixed rules above are inert in a public clone.
cmd/*dgx*/
internal/*dgx*/
cmd/slackgc/
fak/experiments/model-baseline/*.json
fak/experiments/model-baseline/*.log
fak/experiments/model-baseline/*.txt
fak/experiments/model-baseline/turn-agent-realistic/
fak/experiments/agent-live/realistic-workload/
fak/experiments/fleet/eraser/pool-global-*
fak/experiments/fleet/eraser/pool-resource-*
fak/experiments/fleet/eraser/poolDist-*
fak/experiments/fleet/eraser/cross-*

# Local laptop CPU/NVIDIA lane reports written by tools/fak_laptop_test.py.
fak/experiments/gpu/laptop-*.json

# Runtime Prometheus scrape snapshot written by the bottleneck engine (regenerated each
# scrape). The _*_proof.png evidence screenshots are intentionally tracked; this live
# scrape output is not.
tools/_live_metrics.txt
# Runtime grafana/prometheus scrape + query dumps (regenerated; the _*_proof.png evidence
# screenshots stay tracked, these transient text/json dumps do not).
tools/grafana/_*.txt
tools/grafana/_*.json
/node_modules
/fak/lensviz
/fak/q4kdiag
/package.json
/package-lock.json

# Detached /goal worker run logs (node-local)
.goal-runs/

# DoS issue-dispatch run logs + tick state + scratch watchers (node-local,
# regenerated each dispatch tick). The dispatch SKILLS/tools are tracked; the
# run state they write is not. The operator STATUS DOC now renders here too
# (.dispatch-runs/dispatch-status.md) -- private operator telemetry (switcher
# account tag, closure honesty, throughput, silent-worker logs), never public.
.dispatch-runs/

# Belt-and-suspenders: the issue-dispatch STATUS DOC was once committed at
# docs/dispatch-status.md but is now operator-private (renders to .dispatch-runs/).
# A FleetDispatchStatusDoc task registered before the redirect may still write the
# old path until re-registered, so keep it out of the public tree fail-closed.
docs/dispatch-status.md

# idea-scout seen-cache — node-local {source_id: record} of every candidate the
# daily scout has filed, its durable anti-re-file rung (tools/idea_scout.py). The
# SCRIPT is tracked; the cache it writes is local fleet state, not source.
.idea-scout/

# rsiloop benchmark baseline — regenerable per-node state (the measured baseline
# + its pinned SHA, re-derived by `fak rsiloop`). Dotfile by convention; ignored
# per the operator's "keep git status quiet for regenerable bench output" rule.
fak/.bench-baseline.json

# Internal go-to-market / ICP strategy memo — NOT for the public-home repo (same
# class the pre-sync scrub removes: marketing/outreach/strategic-timing). Kept
# local-only so it is never accidentally committed to fleet-public.
/ICP-NEOCLOUD-AGENTIC-PAAS-FIT-2026-06-21.md

# SEO/AEO scorecard SCORES — strategic discoverability/positioning data, the same
# go-to-market class as the ICP memo above. The measuring TOOL is public
# (tools/seo_aeo_scorecard.py); the SCORES go to the PRIVATE repo only
# (`python tools/seo_aeo_scorecard.py --transfer` -> ../fleet/.seo-archive/fak/).
# These globs are the public-side guard: a locally-generated report or baseline can
# never land in this public tree by accident.
/SEO-AEO-SCORECARD.md
/seo-aeo-baseline.json
/.seo-archive/
**/.seo-archive/

# Demo deploy lane — local-only. Carries a real private GCP project id (a
# PUBLIC-SCRUB-POLICY redact-needle the leak gate blocks), so it must be
# redacted or kept in a private repo before it can ever land in fleet-public.
# The deploy SCRIPTS/site live here untracked.
# Exception: deploy/k8s/ is the committed, secret-free Kubernetes manifest
# (placeholders only — no private project id) the persona scorecard and the
# deployment guide point to; it must be tracked so every clone has it.
/deploy/*
!/deploy/k8s/
/.gcloudignore

# Local nested test-clone used as a self-contained "bite test" fixture by
# tools/visual_gen_grade.py — its own git repo (.git inside), node-local and
# regenerable. Ignore so `git status` stays quiet and it can't be staged into
# this repo by accident.
fleet-bite-test/

# Operator-private goal-fleet dispatch prompts (internal orchestration scaffolding;
# the trailing-slash dir form does NOT stop `git add .` from staging the files).
.claude/goal-prompts/*-fleet/
.claude/goal-prompts/*-fleet/**

# Regenerable demorace runtime stdout capture (the `fak/.*.log` rule only matches
# dotfiles; demorace-err.log stays tracked — it is cited evidence in FINAL-ANALYSIS.md).
fak/demorace-out.log

# --- merged from former fak/.gitignore (module at root now) ---
# build output — the compiled binary at the module root ONLY. This MUST stay
# anchored (`/fak`): a bare `fak` also matches the `cmd/fak/` SOURCE directory,
# which silently un-tracked the CLI entrypoint (`cmd/fak/main.go`) before v0.2.
/fak
fak.exe
*.exe
# Windows leaves a `<name>.exe~` when `go build -o` can't atomically replace a
# binary that is still mapped (e.g. a running `fak serve`). Regenerable scratch.
*.exe~

# transient stderr captured by the dogfood launchers (committed evidence is the
# probe JSON next to it, not the log)
experiments/agent-live/*-stderr.log

# Per-session codex dogfood/gate harness output + raw token telemetry. Regenerated on
# every dogfood run (keyed on a codex session id) and re-leaks into `git status` each
# session. These are NOT the committed evidence — deliberate witnesses carry a
# descriptive, schema-versioned name (e.g. openai-wire-seat-guard-live-witness-*.json),
# which these session-id-named globs do not match, so authored witnesses stay tracked.
experiments/agent-live/codex-dogfood-*.json
experiments/agent-live/codex-fak-gate-*.json
experiments/agent-live/*.usage.jsonl

# `go build ./cmd/<name>` drops a same-named binary at the module root. These are
# regenerable artifacts (the SOURCE lives in cmd/<name>/ and stays tracked). Each is
# ANCHORED for the same reason as `/fak` above: a bare name would also match the
# cmd/<name>/ source dir and silently un-track it.
/batchbench
/ctxbench
/fleetbench
/fleetserve
/modelbench
/modelprof
/paritybench
/q8bench
/q8kernel
/sessionbench

# exported model weights + oracle (regenerable via internal/model/export_oracle.py)
.cache/
internal/model/.cache/

# default `fak debug` core-image output dir (scratch; committed evidence is cdb-report.json)
cdb-image/

# downloadable model weights (GGUF/safetensors) — fetched on demand, never committed
experiments/model-baseline/gguf/
*.gguf
*.safetensors

# fleet sweep progress logs (regenerable noise; committed record is the CSV/JSON + PNGs)
experiments/fleet/*.log

# default `-out` of `fak turntax` (cmd/fak/main.go) — a regenerable report written at the
# module root when no --out is given. Committed bench records live under experiments/.
/turntax-report.json

# default report of `fak agent --offline` (the canonical first-command in AGENTS.md /
# the 60-second proof) — a regenerable scratch file dropped at the module root every
# run. The FILE_ADMISSION pre-commit gate already refuses it; ignoring it keeps the
# documented proof from ever leaving a stray file for `git add` to sweep in.
/agent-report.json

# public(fak) vs private(fleet, codename "fleetfak") `git ls-files` parity diff —
# regenerable scratch dropped at the repo root by an untracked peer migration/parity
# helper (a manual public-vs-private tracked-file comparison). No tracked tool emits
# these; the FILE_ADMISSION pre-commit gate would refuse them, but committing the
# ignore protects every session in this shared tree (better than a per-clone
# .git/info/exclude). The literal names today, plus a glob for future relabels.
/.fak_tracked.txt
/.fleetfak_tracked.txt
/.only_in_fak.txt
/.only_in_fleetfak.txt
/*_tracked.txt
/.only_in_*.txt

# default outputs of `fak bench` (GETTING-STARTED Tier 0): `report.json` plus the
# `baseline.json` companion it writes alongside (cmd/fak/main.go). Both are regenerable
# scratch dropped at the module root, same as the turntax/agent reports above. Committed
# bench records live under experiments/.
/report.json
/baseline.json

# fak loop runtime ledger (internal/loopmgr): the append-only hash-chained loop-event
# JSONL the dispatcher/scheduler producers write to (default .fak/loops.jsonl, overridable
# with FAK_LOOP_LEDGER). This is machine-local run state, not source — committing it would
# collide across sessions and replay stale fires. The schema lives in code; the rows are
# regenerable scratch.
/.fak/

# default outputs of the remaining demo subcommands (cmd/fak/main.go), all regenerable
# scratch dropped at the module root by a no-arg run — same class as the report/agent/
# turntax defaults above, so running any demo never dirties `git status` (#311):
#   `fak debug`  -> /cdb-report.json          (the cdb-image/ dir is already ignored above)
#   `fak recall` -> /recall-report.json + /recall-image/ core image
#   `fak dream`  -> /dream-report.json + /dream-image/ (output) + /dream-input-image/ (seed)
# ANCHORED (leading `/`) to the module root only: the committed demo evidence lives under
# experiments/ (e.g. experiments/recall/recall-report.json) and must stay tracked.
/cdb-report.json
/recall-report.json
/recall-image/
/dream-report.json
/dream-image/
/dream-input-image/

# the canonical capability-floor manifest name the docs tell you to author at the module
# root: `fak policy --dump > floor.json` (README, GETTING-STARTED, tutorial, cli-reference).
# A user-authored scratch artifact of the getting-started flow — ignore so the documented
# step never leaves a stray file for `git add` to sweep into this shared tree.
/floor.json
gpucheck_wsl
*.tmp.*

# --- public-issue scrub session scratch (node-local; never commit) ---------------
# One-off issue-text scrub/leak-audit session (tools/.issue_scrub.py + a .scrub_work/
# tree) dumps live GitHub issue bodies, leak-needle audits, and a private-preserve
# ledger to the repo root. These carry the very content the PUBLIC-SCRUB-POLICY gate
# exists to keep out of the public tree (live issue JSON, leaked-number lists,
# private backlinks), so they must never be staged. The scrub TOOL itself, if it is
# ever promoted to a tracked tool, lives under tools/ — this hides only the run state.
/.scrub_work/
/.issue_scrub.py
/.fak_all_now.json
/.fak_final.json
/.fak_issues_now*.json
/.leaked_issue_nums.json
/.move_private_nums.json
# the dry-run / migration text dumps from the same session (and future relabels)
/.added*.txt
/.del_*.txt
/.dryrun_*.txt

# Regenerable turn-tax + kvmmu witness reports. WRITTEN BY TESTS, not curated:
# internal/turnbench/stochastic_test.go writes experiments/turn-tax/turntax-{stochastic,
# breakeven}.json (and reads them back as its own fixtures — "a new file" per the test),
# and internal/kvmmu/kvmmu_test.go drops a kvmmu-report.json. Same regenerable-bench-output
# class as /turntax-report.json above; ignore the regenerable *.json so re-running the
# suite (any seed bump, any clone) leaves git status quiet. The .go SOURCES stay tracked.
# Glob the .json class only (NOT the directory): a dir-slash ignore can't be re-included
# from, but curated artifacts here — e.g. turntax-breakeven.png, produced by
# tools/turntax_plot.py and CITED by TURN-TAX-RESULTS.md — must stay committable so the
# ship-iff-cited gate (tools/public_evidence_manifest.py --check) can see them in CI.
/experiments/turn-tax/*.json
/experiments/kvmmu/*.json

# --- scrub/adjudication session scratch (node-local; never commit) ----------------
# .adjudicate/ holds one-off diffs + copies of the PRIVATE `fleet` repo's scrub
# tooling (fleet_scrub_public_copy.py / fleet_PUBLIC-SCRUB-POLICY.md / fleet_SUNSET.md),
# which carry the real-secret denylist by reference — the exact content the
# PUBLIC-SCRUB-POLICY leak gate keeps out of this public tree. Never stage it.
/.adjudicate/

# --- credential-shaped stray files (the FILENAME is the secret) -------------------
# A stray shell redirect (e.g. `cmd > "$TOKEN"`) can create a file whose NAME is a
# live-shaped Anthropic OAuth token (sk-ant-oat01-...). The 46-byte content is
# innocuous (a path), but the token-shaped filename would be written into git
# history by any `git add -A`. Never stage it. (Rotate the token + delete the file
# is an operator action — this rule only stops the leak vector.)
sk-ant-*
sk-ant-oat01-*

# --- runtime demo artifact (regenerated on every run) -----------------------------
# cmd/memqdemo writes memqdemo-report.json into its working dir on each run as the
# machine-readable witness of that run; it is a build product, not source. Track the
# code that emits it, not the emission.
memqdemo-report.json

# --- ad-hoc session scratch on the shared trunk (node-local; never commit) --------
# These re-leak into `git status` every session on the shared trunk (the same
# trajectory-audit finding the root *_out.txt / *_err.txt rules above address) and
# carry no durable signal — they are one-off analysis scripts, scorecard JSON dumps,
# and commit-message drops a session writes while working. The TOOLS that emit them
# (tools/code_slop_scorecard.py, `fak commit -F msgfile`, the AEO scorecard) are
# tracked; this transient run state is not. Anchored to the module root where the
# name is generic, so a tracked file of the same name elsewhere is unaffected.
#   scratch_*  : ad-hoc throwaway analysis scripts / JSON a session writes at root
#   /slop*.json: code-slop-scorecard output (regenerable via the tracked scorecard)
#   .aeo_* .aeo-*: agent-experience-optimization scorecard session scratch
#   /_tmp_*    : one-off gate/preview scratch (json/md)
#   /*_msg_*.txt: `fak commit` message drops (commit_msg_*, docs_msg_*)
#   /err.txt   : a bare stderr redirect drop
/scratch_*
/slop.json
/slop_*.json
.aeo_*
.aeo-*
/_tmp_*
/*_msg_*.txt
/err.txt

# Trajectory-audit drops written by tools/session_audit.py (the /trajectory-audit skill,
# `audit --json OUT`). These carry PRIVATE operator telemetry — per-session dollar costs,
# local namespace breakdown (e.g. C--work-job, C--WINDOWS-system32), and tool-mix counts —
# the same go-to-market/operator-private class as the dispatch-status doc and SEO scores
# above, so they must NEVER land in this public tree. `audit-sessions.json` is the name a
# large-window audit lands at; the dated `trajectory-audit-YYYYMMDD.{md,json}` form is the
# skill's documented --md/--json example. The committed analysis lives in the explainer
# docs/notes that cite specific numbers; the raw machine-local dump is not source.
/audit-sessions.json
/trajectory-audit-*.json
/trajectory-audit-*.md
/.verify1259

# learning-debt dispatch seen-cache - node-local {source_id: record} of every
# learning-scorecard HARD defect already filed as a triage issue; its durable
# anti-re-file rung (tools/learning_debt_dispatch.py). Peer of .idea-scout/.
.learning-debt-dispatch/
