ff-agents

Plugin ff-agents from marketplace final-factory-agents in Final-Factory/final-factory-agents. Commands read from the repo's manifest — today.

Skills (30)

• add-network-operation

  Add a new gameplay mutation (network operation) to Final Factory's deterministic lockstep pipeline - the request/completed op pair, host-side validation, payload baking, broadcast, and the single-player shared path. Use when adding ANY new gameplay state mutation, when wiring a client intent to auth

• ci-release

  Cut a release through CI on the ffbox build server — write the release notes, bump the version (FFVersion.cs + bundleVersion) and push, follow CI through the Windows/Mac main+demo builds, tests and Steam uploads, then post the patch notes as Max in #dev-patch-notes. A requested release is done only

• concept-art

  Paint concept art (ships, enemies, bosses, buildings, items) with Stability AI's image API: write a prompt in Final Factory's style, paint over our Blender renders (structure), borrow the look of an existing model (style), recolor a part (\"this, but redder\"), and bring each set to the person inlin

• deep-think

  Hand a hard problem to the deep-thinker agent (Astra extra-high in Codex; Opus 5.5 xhigh in Claude Code) — spec/plan authoring, adversarial review of a plan or diagnosis, or root-causing a bug that resisted a first pass. Builds the brief so the agent is grounded but NOT anchored by the driver's assu

• determinism-audit

  Verify multiplayer determinism work — the paired two-editor localhost audit (ParrelSync clone setup incl. the FMOD symlink gotcha, .ff-local-automation.json, per-heartbeat fingerprint comparison) plus the persistent determinism testcases (feature 009) and the wrapper audit scripts (run_join_catchup_

• drive-game

  Drive the running Final Factory game in the Unity editor via the MCP bridge — enter play mode, press or hold keys, open the in-game menu, load saves, and take screenshots (the canonical capture recipe other skills point at; gameplay recipes in recipes.md). Use when asked to run, interact with, or sc

• editor-ops

  Final Factory Unity editor operations via the MCP bridge: pinning the right instance, compile verification (stale-assembly and .meta traps), the EditMode suites, recovering a hung editor or bridge, the Unity CLI channel, long-run monitoring. Use BEFORE any task that needs the live editor: tests, a c

• evidence-gate

  Before any consequential action (spending money, publishing, a live setting, a release, merging a simulation or player-visible change, deleting, reporting a fix as done) or recommending one: list the choices, say what each rests on (measured, sourced or guess), settle your guesses, name how it could

• ffu-add-op

  Add a new gameplay mutation to Final Factory Universe (FFU), the Rust engine in Final-Factory/ffu, as an `Op` through `Sector::submit` - the enum variant, its op-log encoding and body length, applying it in phase one, refusals, the hash and snapshot rules, rate mode's wake list, the agent API's `set

• ffu-build-test

  Build, test and land a change in Final Factory Universe (FFU), the Rust engine in the private Final-Factory/ffu repo - the toolchain on FF Factory machines, the checks CI runs (fmt, keep-sorted lint, sim rules, clippy, tests, hashcheck, crosscheck), the snapshot and hash rules a sim change must keep

• ffu-determinism

  Prove or debug determinism in Final Factory Universe (FFU), the Rust engine in Final-Factory/ffu - the hashcheck, the cross-machine crosscheck and crosscompare (Linux, Windows, macOS), thread-count invariance, recording and exact replay, planting a fault, and bisecting two recordings to the first di

• ffu-drive

  Run and look at Final Factory Universe (FFU), the Rust engine in Final-Factory/ffu - bounded headless runs, the `ffu` window, offscreen stills, clips and frame stats, the agent state API (`ffu-headless serve`, JSON-RPC - query, get, set as ops, step, watch, capture), the `ffu-mcp` sidecar that survi

• ffu-multiplayer

  Run and check multiplayer in Final Factory Universe (FFU), the Rust engine in Final-Factory/ffu - an `ffu-server` sector or world shard, followers, joining clients and the window as a client, seeded bots and the thin `ffu-bots` fleet, the delay and loss proxy, peered shards with a replica and a stan

• ffu-playtest

  Run a goal-directed agent playtest of Final Factory Universe (FFU), the Rust engine in Final-Factory/ffu - pick a goal and a stop condition, play it as ops through the agent state API or the `ffu-mcp` tools (place, remove, set_recipe, insert), observe with query, get, watch and stats, look with capt

• ffu-ui

  Build and verify UI in Final Factory Universe (FFU), the Rust engine in Final-Factory/ffu - `ffu-ui`'s retained tree as data (roles, bounds, Tab order, the arrow focus graph, the accesskit tree), the agent API's `ui_tree`, headless stills of a panel at several sizes, its bounds, focus, minimum text

• github-pr-review

  Review an open PR in Final-Factory/FinalFactory and leave inline comments on the diff in Ben's voice (they post from Ben's gh account). Use when asked to review a PR, leave PR comments, or "review whatever's open". Comments are terse and casual but must name a real, code-verified problem; no summary

• handoff

  Prepare a clean handoff before the user clears context. Captures the current work state (what's done, what's next, blockers, key facts) into the durable session-handoff + memory + docs and commits it, so the next Claude Code or Codex session can resume with zero prior context. Invoke when the user s

• honest-coop-play

  Run a sitting of Final Factory's HONEST three-player co-op game — Ben's standing goal (2026-09-22) that Claude beats the game with NO cheats, in ONE continuous game, with a distinct agent playing on each of the three machines (M5 host, M3 and BEAST clients) coordinating over a shared board. Use when

• learnToPlay

  Fold gameplay knowledge learned this session into the two HowToPlay guides — the public player-framed kit/HowToPlay.md (finalfactory-agent-kit) and the internal code-traced docs/HowToPlay.md. Use when the user says "/learnToPlay" or asks to update the how-to-play doc, or after you worked out a non-o

• massdriver-visual-e2e

  Agent-runnable visual + behavioral e2e regression for mass drivers (feature 012). Boots a solo FlatMap world with a three-pair mass-driver cell (in-range, exact-boundary, out-of-range), asserts the laser in-range indicator, live firing/delivery, and the receiver-capacity gate via execute_code (objec

• mp-beta-deploy

  LAST-RESORT FALLBACK — the manual M5 build and Steam upload of the multiplayer Mac + Windows players. The normal route is a master version bump through ci-release. Use only when ffbox CI is actually down AND Ben has OK'd a manual build, or Ben explicitly asks for a special build that must not come f

• plain-writing

  Ben's standing style rules for prose that does not read as AI-generated. Use when writing or revising anything a person will read as prose - slide decks, presentations, documentation, spec and plan bodies, READMEs, commit message bodies, PR descriptions, Discord posts, and long chat summaries. Also

• playtest

  Run a goal-directed agent playtest of Final Factory through the 020 harness — boot or attach a session, drive the game with ffauto pointer/ui/movement commands, observe via state snapshots, screenshots, and temporal visual episodes (the Watch/playback surface), wait on predicates non-blockingly, jud

• project-memory

  Accumulated Final Factory project memory — standing user feedback plus hard-won Unity, Burst/ECS, baking, modding, and play-mode lessons. Consult at the start and end of every Final Factory repository development task so fixture-selection (and, in an ffbox run only, the @lothsahn completion note) is

• publish-skills

  Add, edit, or fix a skill or subagent role, or record a durable project lesson, in the final-factory-agents marketplace repo, and publish it (version bump, validate, push) so every machine gets it. Use when the user asks to change a skill, add a skill or role, "remember this" or "capture this lesson

• resumeFromHandoff

  Resume work after a context clear by reading the machine-local `local-handoff.md` that /handoff wrote. Use when the user says "resume", "pick up where we left off", or invokes this right after clearing context — it replaces copy-pasting a next-session prompt.

• steam-upload

  Upload a multiplayer build to Steam from the M5 Mac with steamcmd — the login/upload mechanics mp-beta-deploy relies on, including the cached-token login recipe (the "it keeps asking me to log in" fix). Not for releases, which go through ci-release on ffbox.

• unity-ui

  Build and verify Final Factory's Unity uGUI screens (panels, windows, HUD, popups, Steam Deck sizing) the way a player sees them: uGUI layout pitfalls, the Deck tour, ui_check.py pixel checks, the ui_layout.py census (overlaps, drift, moves only as asked, hud-pins.json), and the design gate (design-

• update-docs

  Audit the repo's living documentation for staleness after a stretch of work and bring it up to date. Cross-checks every status/path/API claim against the ACTUAL code + git state (docs lie about their own currency), fans out read-only auditors over the doc set, then fixes the real drift and commits.

• watch-video

  Watch a video with its sound and judge it like a viewer (cuts, pacing, dead air, music edits, loudness), and record and review 60 fps clips of visual effects (record_clip, watch_video --mode vfx: lifetime, pops, flicker, judder, frame by frame, against the approved clip). Use before any trailer or v

Subagents (10)

• Explore

  Read-only codebase search and fan-out exploration — locating code, tracing symbols, mapping naming conventions across many files. Shadows the built-in Explore so background searches run on Haiku instead of the session model. Use for "where/how is X", usage sweeps, and broad reads where you only need

• build-verifier

  Runs the compile-verify ritual on Sonnet: pin the Unity MCP instance, recompile, grep the on-disk Editor.log for compile/ILPP errors and the reload marker, run the EditMode tests the change touches (test_select.py), and report a verdict with raw evidence. Delegate on request when the output would bl

• code-analyst

  Read-only code questions that need judgment (Opus 5.5, high): \"does this iterate an unordered collection the simulation reads\", \"is this write reached from an RPC\". Answers ONE question with file:line evidence and what it ruled out, keeping the reading out of the parent's context. Its answer com

• deep-thinker

  Hard-problem specialist on Opus 5.5 at xhigh effort (a fresh, unanchored context one effort level above the driver; Fable 5.1 is the explicit escalation) — design/spec authoring, adversarial review of a plan or a change, and root-causing bugs that resisted a first pass. Use when the problem needs la

• game-driver

  Executes FULLY-SPECIFIED Final Factory drive legs via the Unity MCP bridge on Sonnet — pump-and-poll loops (EditorApplication.Step batches + wait.status polling), ffauto command chains, movement/mining legs, UI click sequences, state-snapshot collection. Delegate only when the orchestrator has alrea

• implementor-sonnet

  Implementation legs OFF the simulation on Sonnet 5.5 (high): ONE designed, scoped task in UI, input, camera, presentation, audio, editor tooling, scripts or tests of existing behavior, end to end (code, tests, compile-verify), reported as a reviewable diff. Simulation, determinism, netcode, save sta

• implementor

  Implementation legs on Sonnet 5.5 (high) for anything touching simulation, determinism, netcode, save state or a crown-jewel surface, and the escalation target when implementor-sonnet fails: ONE designed, scoped task, end to end (code, tests, compile-verify), reported as a diff summary. Off-simulati

• mech-executor

  Fully-specified MECHANICAL edits on Sonnet — renames, moving code, boilerplate, test scaffolding, doc/comment updates, localization-string edits, find-and-replace across files. Delegate only when the change is unambiguous and the caller has already decided WHAT and WHERE. NOT for determinism-critica

• scout

  Cheap read-only single-answer lookups — "where/how is X defined", symbol usages, a config value, which file owns Y. Haiku-tier. Delegate focused investigations here instead of searching inline so the main context stays lean.

• ui-critic

  A fresh design critic for Final Factory UI stills (Opus 5.5, high): given only the stills, the before, the reference panels, the person's words and the unity-ui rubric, it grades each still and lists what a player or Ben would see at a glance (BROKEN and UGLY first) in critic.md. Run a NEW one on th

Similar plugins