AI Agent Workflow Collection

One repeatable pass that makes a doc read like a person wrote it, not a model. Runs the doc-appeal scorecard (tools/docappealscorecard.py), turns each HARD defect into a required edit (em-dash flood, bold-emphasis flood, run-on / overlong sentences, walls of text, stacked "X, not Y" contrast frames, a dense or unanchored lead, LLM-scaffolding phrases) and each SOFT signal into a judgment call, retires appeal-debt worst-axis-first WITHOUT changing any claim, number, or link, re-measures to PROVE the debt dropped, and commits only the doc lane by explicit path. The prose-voice counterpart to refresh-readme (freshness) and quality-score (code). Use to de-LLM-ify the README or any reader-facing prose doc, or on a /loop cadence to keep the front door human.

Map the current "what is limiting us right now?" state across the running agent fleet and the live GitHub issue backlog. Runs fleet bottleneck detection plus issue triage, records the dominant system bottlenecks, open-work bottlenecks, and the durable process loop to run next. Use when the operator asks for bottlenecks, open-work constraints, fleet health, issue/backlog limits, or a durable ongoing process for keeping both visible.

One repeatable RSI pass over claim reproducibility; run the claim-repro scorecard, retire unfalsifiable witness debt worst-first by adding the real artifact/test/path, re-measure, and commit only the claim-repro lane.

Audit a Claude Code skill's per-invocation context use, then propose a context-bundling helper + SKILL.md edits to cut waste. Reads a representative session JSONL, ranks the largest tool results, traces them back to SKILL.md instructions, and proposes a fix. Stops after the proposal — the operator approves before code is written. Use when a skill feels slow, expensive, or "burns context" — typical signal is a SKILL.md over ~300 lines that reads multiple files >5 KB on every run.

Commit finished work cleanly on the shared trunk — lint the subject with fak commit --preview, then stage-and-commit EXACTLY your paths in one locked step via fak commit --path ... -m "...", verify the landed path-set and message are yours, and push when asked. Mechanizes the repo's "commit clean by default" mantra (trunk-only, explicit pathspec, DCO sign-off, Conventional-Commits subject with a bindable (fak ) stamp). Use when the user says "commit this", "ship my work", "commit cleanly", "land my change", or when green work is finished and ready to land on the shared trunk.

One repeatable pass that keeps every number and status fak reports PROVENANCE-HONEST - each value labeled by what fak CONTROLS (witnessed/authored) vs what it only OBSERVES (relayed from an external party), and no bad observed value blamed on a fak action. Runs the conflation scorecard (fak conflation-scorecard, the Go verb backed by internal/conflationscore) over the fact-reporting surfaces (Prometheus metric help, the fak guard exit summary), turns each HARD defect into a required edit (label an unlabeled external value OBSERVED; correct prose that attributes a provider-side miss to a fak action), retires conflation-debt worst-first WITHOUT changing any number or logic, re-measures to PROVE the debt dropped, and commits only the scorecard lane by explicit path. The truth-maintenance counterpart of appeal-score (prose voice) and observability (what is measured). Use after adding a metric/exit-summary that reports an external value, when a dashboard mislabels whose number it is, or on a /loop cadence to keep the reporting surface honest about its own boundary.

One curation pass over a research/doc cluster — reconcile the project's index doc (e.g. INDEX.md) against the docs and scripts actually on disk (add missing entries in the house format, fix dangling references, refresh counts/date/git-context), gitignore regenerable build artifacts, then commit ONLY the quiescent curation lane (docs/experiments/tools/index) by explicit path — never an actively-built code tree. Concurrency-safe by construction: when the repo is a live multi-session tree, the pass excludes any file-tree a peer is writing right now. Use after a burst of doc-writing, when the index drifts from disk, or on a /loop cadence to keep the cluster clean and indexed.

Apply the concept-disambiguation pass to ANOTHER section of fak - an under-covered watched family (gateway-engine, guard-gate, ...) or a newly-discovered overloaded root (evict, decision, render, plan, pool, layout) - and, when a section is bigger than one sitting, file a GitHub ticket that scopes it with real context. Two modes over the same scorecard (tools/conceptdisambiguationscorecard.py): APPLY picks the worst-covered section from --gaps, surfaces its genuinely-DISTINCT confusable concepts (filtering inflections), adds grounded + glossary-anchored rows, draws the distinctions, re-measures to PROVE coverage rose, and commits the lane by explicit path; TICKET enumerates the sections that still need the pass (under-covered families + missed roots + cross-cluster canonical collisions) and opens one GH issue per section with the confusable tokens, file evidence, and scorecard-tied acceptance criteria. Use after running disambiguation-score when the backlog is too large for one pass, to onboard a new overloaded root, or to turn the coverage backlog into tracked work.

One repeatable pass that keeps fak's growing namespace CRYSTAL-CLEAR - each similar-sounding concept (cache / vCache / KV cache / cachemeta / the provider prompt-cache; guard vs gate; the two witnesses) given one canonical name, a written definition, and an explicit line drawn against the siblings it is confused with. Runs the concept-disambiguation scorecard (tools/conceptdisambiguationscorecard.py) over a data dir of confusable-concept rows cross-checked against the tree (the grounding token must appear in the production corpus; the glossary anchor must exist; a distinctfrom reference must resolve), turns each HARD defect into a required fix (rename a true canonical collision, write a missing definition, draw + anchor a missing distinction, replace a fabricated grounding) and each uncovered tree token into a coverage row to ADD, retires disambiguation-debt worst-first, re-measures to PROVE the debt dropped, and commits only the scorecard lane by explicit path. The NAMING-clarity counterpart of conflation-score (number provenance) and product-score (can a person use the concept). Use after adding a confusable name, when two concepts blur, or on a /loop cadence to keep the vocabulary from fogging as it grows.

One repeatable pass that keeps the dojo's self-improving RSI loop actually CLOSING on our own billed usage - the real calibration history the dojo measures - instead of a plan-mode scaffold that never acts. Drives the native dojo-RSI verbs (fak dojo-rsi fold|propose|rewrite|run|loop|trend) over a scored dojo report, picks the worst-calibrated MEASURED, NON-FLOOR cell, previews the one-literal recalibration, self-scores it on a strict FoldCalibrable drop + a sample floor + an external witness, routes REPROJECT/HARVEST/floor cells to the human/agent arm, and commits only the dojo lane by explicit path. The calibration-loop counterpart of guard-rsi-score (which scores the guard's verdict loop). Use after a change to a dojo lever or the claim registry, after a fresh corpus scan, or on a /loop cadence to keep the gym's predictors getting better calibrated over time.

Price a proposed multi-agent fan-out before launching workers. Use when a packet, goal fleet, or hand-written plan would run several agents over declared file trees and you need DOS to catch collisions before any worker starts.

One repeatable pass that turns an outward field idea into grounded backlog WITHOUT guessing whether fak already has it — the dogfood-witnessed capability-import loop. Before filing "fak should add X" from a named external system (Letta/MemGPT, Mem0, Zep/Graphiti, Cognee, vLLM/SGLang, a dated paper) or a row from the RESEARCH-/industry field scans, it DOGFOODS fak's own self-query surface (fakfeaturequery / fak capabilities / fak index docs|leaves|verbs|claims) to witness PRESENT / PARTIAL / ABSENT, grounds each real gap in a file:line seam, and files epic-anchored issues carrying the named source + the dogfood witness + the seam + a first checkable step. The human-curated, witness-first counterpart to the automated idea-scout (which dedups a candidate only against already-filed issues — a seen-cache, issue-body stamp, and title-Jaccard index — and never asks fak what it already has in the codebase); the product/agent-capability counterpart of sota-check (kernels) and industry-score (the competitive map). Use when reading a field/SOTA/research note and wondering "do we already have this?", before filing a capability-gap issue, after a competitor or paper ships a capability, or on a /loop cadence over the docs/notes RESEARCH- corpus to convert inert research into witnessed, grounded backlog.

Run ONE wave of N fak-guarded ultracode sessions against the top open issues under a closing target and a wall-clock deadline — price, render fuel, launch, monitor, reconcile from git, release. N defaults to 30 (30 issues, 30 sessions, 4 hours). Use when the operator says \"spawn N ultracode sessions\", \"fleet wave\", \"close the top 30 issues in 4 hours\", or asks for a bulk guarded fan-out with a stated goal. The goal-shaped single door over /super-loop (the raw launcher) and /wave-harvest (the reconcile half); the four traps that silently void a whole wave are in the body.

One repeatable pass that keeps the RSI loop for fak guard actually CLOSING on our own usage - the real, hash-chained decision journal fak guard writes - instead of a plan-mode scaffold that never closes. Runs the native guard-RSI scorecard (fak guard-rsi-scorecard) over the two guard RSI loops (the hardware-gated LATENCY loop tools/guardhoprsi.py and the hardware-free VERDICT loop fak guard-verdict-rsi), scores maturity (can it honestly close?) + realized value (does it run on our usage?), turns each HARD defect into a required affordance to ADD (a journal-grounded loop, a deterministic verdict-quality metric, a non-forgeable keep-bit, real adjudicated rows, control-pane membership, a paired honesty test), retires guardrsidebt worst-first, re-measures to PROVE the debt dropped, and commits only the guard-RSI lane by explicit path. The product-loop counterpart of rsi-maturity (which scores the generic internal/rsiloop engine). Use after a change to either guard RSI loop, after a guarded session adds journal rows, or on a /loop cadence to keep the guard learning from our workflow.

One repeatable pass that keeps fak's competitive story honest AND complete — graded industry-first, not from what fak happened to measure. Runs the industry scorecard (tools/industryscorecard.py) over a modular data directory (tools/industryscorecard.data/): a researched taxonomy of the dimensions the LLM-serving / agent-infra field competes on (vLLM/SGLang/TensorRT-LLM/llama.cpp), the current SOTA bar on each with a dated source, and fak's honest position — mostly named gaps. It drives two numbers, coverage (of the field) and parity-debt (honesty of the rows), and updates on two cadences: as the industry moves (a new dimension drops coverage; --stale lists SOTA bars due a re-check) and as fak moves (a benchmark turns a no-claim into a measured row). Regenerates the modular doc folder docs/industry-scorecard/ and commits only the scorecard lane by explicit path. The OUTWARD-facing counterpart of repo-hygiene/code-quality/appeal. Use after a benchmark lands, when a competitor ships a number, when the field adds a dimension, or on a /loop cadence.

One repeatable pass that makes the milestone report's CLIMB and ROADMAP retirable by the RSI loop — the milestone counterpart of quality-score (code) and stability-score (trust under iteration). Runs the milestone scorecard (fak milestone-scorecard --json) over the report's OWN two dimensions — the distance-from-MATURED climb shortfall across the M0..M7 support-maturity grid PLUS the un-progressed tracked-epic roadmap gaps — folds them into one deterministic milestonedebt integer + a worst-first milestoneworklist, retires debt worst-first (climb the lowest-rung cell to M4, then close the most-open discrete epic), re-pins the climb ratchet on a real climb improvement, re-measures with --compare to PROVE the debt dropped, and commits only the milestone lane by explicit path. COMPOSES — does NOT duplicate — support-maturity (which fences each cell to its regime ceiling); milestonedebt scores raw distance-to-MATURED across the grid as the headline climb, alongside the roadmap. Use after a cell climbs a rung, after an epic closes its children, on the milestone report cadence, or on a /loop cadence to keep the milestone program retirable like every other surface.

One repeatable pass that keeps agent-steer prose leading with the AFFORDANCE, not the prohibition. Runs fak score negframe over the steer-prose corpus (AGENTS.md, CLAUDE.md, the skills, or explicit paths), reads the negframedebt (mechanical negatives with an unambiguous positive rewrite) plus the judgement-tier soft signal, retires the mechanical debt worst-first by applying the suggested reframe, checks the --since ratchet before landing a steer-prose change, re-measures to PROVE the debt dropped, and commits only the scorecard lane by explicit path. Use after editing AGENTS.md/CLAUDE.md/a skill, when a new negatively-framed directive is proposed, or on a /loop cadence to keep steer prose reading as "do this" instead of "don't do that.

One repeatable pass that keeps fak light to DRIVE — the operator-facing counterpart of steerability-score. Runs the operator-heaviness scorecard (fak operator heaviness) over the live operator surface (the cmd/fak dispatch table, the front-door verb's flag set, the dos.toml refusal vocabulary, and whether the doc map makes the steering surfaces discoverable), reads the unbounded heavinesspressure headline plus the HARD heavinessdebt gate, drives pressure DOWN and HARD debt to zero by REAL surface consolidation (group verbs, cut front-door flags, fold refusal reasons, wire a missing doc-map entry or appeal channel) — never by gaming a detector, re-measures to PROVE the pressure fell, regenerates the committed snapshot, and commits only the touched lane by explicit path. The operator-surface counterpart of steerability-score (package-graph shape) and the steering-effort companion of quality-score (code defects). Use after a verb, a front-door flag, or a refusal reason is added, when the dispatch table "feels" like a navigation wall, when fak guard grows another flag, or on a /loop cadence to keep the surface an operator must hold flat as the repo grows.

One repeatable pass that keeps fak serving the top-10 personas who land on it — from the free-tier dev who downloads a binary and won't read a word, through the infra engineer who has to operate it, to the researcher who wants to reproduce it. Runs the persona-readiness scorecard (tools/personareadinessscorecard.py) over the git-tracked tree, turns each unmet HARD affordance into a required thing to ADD (a prebuilt-binary release, a deployment guide, a determinism witness, a refusal vocabulary, a green gate), retires persona-debt worst-served-first, re-measures + regenerates the snapshot to PROVE the debt dropped, and commits only the scorecard lane by explicit path. The go-to-market counterpart of agent-readiness (one persona: the AI agent), product (the concepts), and industry-score (the field). Use after a change to a persona's entry path (a release, a deploy doc, an integration recipe, the policy spec), when adding a persona to the roster, or on a /loop cadence to keep every front door open.

Ceremony rules for shipping a phase of a phased plan — when to release, when to emit a handoff prompt, how far to go on type-strengthening, when to fold or split phases, and the hero-exit rule that prevents plans from becoming open-ended. Load when shipping a phase of a docs/-plan.md (or equivalent) plan.

One repeatable RSI pass over CODE quality — the code-side counterpart of refresh-readme. Runs the code-quality scorecard (tools/codequalityscorecard.py), reads the code-debt work-list, retires debt worst-first using ONLY the safe, genuine classes (gofmt, real tests for untested packages, safe god-function extraction), re-measures to PROVE the number dropped, grounds the ship in DOS (dos commit-audit on the new commit, dos review for the shipintegrity KPI), and commits by explicit path. Use to baseline code quality, drive the code-2x program (halve code-debt, then halve again), or on a /loop cadence to keep the kernel from rotting. The code's checking layer, the way refresh-readme is the README's.

The super-loop-family member that ASKS instead of ships. It launches detached workers whose only job is to ask 5–10 hard, honest questions about what the repo is doing — the question no other agent has asked, the one everyone's afraid to ask, the one that's opposite what the repo claims, the steelman of the other side — and append them to a durable ledger (docs/questions/asked.jsonl). A SEPARATE next-step loop, in a SEPARATE context window, turns qualifying questions into gh tickets for actual work. Use when the operator says "ask the hard questions", "what aren't we asking", "run a question loop", "start the asking loop", "question what we're doing", or wants a standing cadence of provocations rather than more issue-draining. NOT idea-scout (external feeds), NOT /super-loop (ships fixes), NOT the Go superloop.Super interior node.

Refresh the recent-operational cachevalue numbers in a guarded doc (e.g. docs/integrations/fable5-more-usage-for-free.md) when this-week's telemetry has moved on. Re-derives the frozen snapshots from live fak cachevalue report, reconciles the doc's rendered numbers + snapshotdate to the fresh capture, and re-runs the hermetic audit until it is clean. The audit (tools/cachedocnumbersaudit.py, gated in make cachedoc-numbers-lint) binds every rendered number to a committed snapshot field and checks the arithmetic invariants the doc asserts — this skill is the maintenance loop that keeps that binding true as the fleet/dev windows advance. Distrusts the stale doc: the new numbers come from a fresh --json capture, never from editing the visible prose in place. Use when the audit WARNs on staleness, when a cachevalue doc looks out of date, or on a cadence to keep the operational docs honest.

One repeatable pass over README.md — the front door — that keeps ONLY the most important points current and honestly framed. Runs the freshness auditor (tools/readmefreshnessaudit.py), turns each FAIL into a required edit and each WARN into a judgment call, applies the three front-page laws (SOTA-vs-us-never-naive, 6th-grade/Feynman-but-accurate, wide-audience), re-stamps the readme-verified marker, and commits ONLY README.md (+ the tool) by explicit path. Use after a release / version bump, after a headline number changes, when a link dies, or on a /loop cadence to keep the front page from rotting. The README's checking layer, the way curate-cluster is the index's.