coworld-crewrift

Use to identify and download Coworld episode artifacts — replays, results, and per-agent logs — for completed episodes, or STREAMED live from a still-running experience request (--watch: each episode downloads as it finishes, no waiting for the batch). Triggers: 'download the replay/logs for episode X', 'pull the last N episodes <player> played', 'fetch artifacts for this experience request / pool / round', 'stream artifacts while the request runs', 'get the episode data for post-mortem'. Game-agnostic (Crewrift, amongthem, etc.).

Use to create and monitor Coworld experience requests — hosted batches of episodes you define (target, roster, roles, count) for evaluating a policy against a live field. Triggers: 'run crewborg vs the top opponents', 'make an experience request', 'request N hosted games', 'A/B a policy against the league', 'measure the imposter', 'set up an evaluation battery'. DEFAULT FLOW after create: launch the STREAMING pipeline in the background (step 4) — artifacts download and analysis prep overlap the still-running episodes; don't wait for the batch to drain.

Use to run your own built player policy in a LOCAL Coworld episode and watch it — the Gate-1 smoke test ('did my change take, does it connect → play → exit cleanly?'). Triggers: 'smoke test the player locally', 'run a local game', 'run my policy locally and watch it', 'does the build still work', 'open the replay locally'. Game-agnostic; this is correctness only, NOT a competitive matchup (you can't run other users' policies locally).

Use to submit an ALREADY-UPLOADED policy version to a Coworld league and monitor whether it QUALIFIES, then competes (and becomes champion). Triggers: 'submit crewborg to the league', 'did it qualify', 'is it disqualified / champion', 'watch the qualifier', 'monitor standings after submitting'. SUBMIT is the public, effectively-irreversible, champion-making action — explicit human go-ahead only. (Building + uploading a version is the separate `build & upload` skill.)

Use to decide whether a crewborg change ACTUALLY helped — A/B the candidate against the baseline head-to-head, fresh, right now, against the same field. Triggers: 'did my change help', 'compare v71 vs v70', 'A/B test crewborg', 'is the candidate better', 'did fixing the imposter regress the crew'. Runs two MATCHED fresh experience requests, diffs role-split metrics with significance (compare.py), renders a comparison report, and guides a qualitative side-by-side. It's also the 'designed run' that crewrift-experiment hands off to.

Use to build and query the Crewrift event warehouse — a policy-indexed DuckDB/Parquet dataset of per-tick gameplay events (kills, follows, proximity, votes, tasks, chat) over many episodes — for deep, mechanistic, cross-episode questions about a policy's behaviour. Triggers: 'how often is crewborg near a crewmate without killing', 'who trails crewborg', 'where does it abandon tasks', 'does it vote real imposters', 'build the warehouse for this round', 'query the events', 'stream an experience request into a warehouse'. For a FRESH experience request, stream_eval.py builds the warehouse WHILE the episodes run (the default; builds are incremental). This is the deep-dig mainstay after crewrift-survey flags something.

Use to turn a SET of Crewrift episodes (an experience request, a policy's recent league games, a tournament batch) into a fast, polished HTML survey: a per-policy stats table, a policy×policy win heat map, and a short list of interesting episodes (with replay links). Triggers: 'survey these episodes', 'how is crewborg doing in this batch', 'who beats whom', 'give me the report on this XP request', 'which games should I watch'. Fast + lightweight (results.json + episode.json only). Pair with coworld-episode-artifacts (to pull the episodes); the DEEP per-episode dissection is a separate skill.

Use to build the crewborg image and upload it as a new policy version — the routine, inert, every-iteration action that gives you a runnable artifact to smoke-test and evaluate. Triggers: 'build crewborg', 'upload a new version', 'rebuild and re-upload', 'ship a version for testing', 'upload with the LLM on'. Uploading enters NO competition; submitting to a league is the separate coworld-policy-lifecycle (submit & monitor) skill.

Use to turn crewborg's signals (a survey, a warehouse, league results) into an explanation and a small set of VARIED, mechanistic improvement hypotheses — what is going wrong, why (pinned to a code location), and which directions are worth testing. Triggers: 'why is crewborg weak at X', 'explain these signals', 'where are we weakest', 'what should we try', 'form hypotheses', 'turn this report into directions'. Explanatory + generative: it presents hypotheses + suggests experiments; the actual testing is the crewrift-experiment skill.

Use to test ONE hypothesis about crewborg's behaviour rigorously — design an experiment, adversarially criticize it for falsifiability, redesign until it's valid + cheap, run it, and reach a verdict. Triggers: 'test this hypothesis', 'how do we find out if X', 'I think it might be Y — let's check', 'design an experiment for this', 'does this actually test what we think'. Standalone on a hunch, or called by crewrift-diagnose with a hypothesis it generated. Leans on crewrift-event-warehouse (re-analyse existing data), crewrift-ab (a designed run), and trace-logs (instrumentation).

Periodic (≈weekly) review of crewborg's tentative-lessons archive: cluster the lessons that keep REAPPEARING across independent session buffers, propose promote/keep/cull with recurrence counts, and — on the human's call — graduate the keepers into best_practices.md and retire the reviewed buffers. Triggers: '/lessons-review', 'review the lessons archive', 'which lessons keep reappearing', 'graduate lessons'.

Crewrift-specific XP-request eval sizing and shaping. Use when running any hosted eval for crewrift policies — diagnostics, candidate verification, guardrails, or targeted runs against a specific opponent. Covers the 40-80 game minimum, leaderboard-variance rosters, targeted pairwise runs, and the role/seat/penalty breakdowns required before a verdict.

Crewrift-specific grounding for the optimizer loop — scoring constants, role-by-color census, the trace.db artifact schema and server_tick replay join, .bitreplay reconstruction via the Nim simulator, fetch/build/submit commands, CREWBORG_* trace flags, the -100 disconnect taint rule, map/navigation facts, and the replay viewer. Use when optimizing a Crewrift policy (e.g. crewborg) and you need the game's concrete commands, schema, and constants.

The policy-specific optimizer guide for crewborg-aaln — Aaron's Crewrift league policy. Read this first when optimizing crewborg-aaln. Covers the cognitive-stack architecture, the variant/experiment env flags, the Crewrift league + Observatory IDs, build/run/test commands, the exact files to edit when improving behavior (suspicion, mode selector, vote policy, modes, navigation), and the trace/debug format. Pair with games/crewrift skills for game mechanics and skills/ for the optimizer methodology.

Foundational methodology for autonomous policy optimization. Use before running or designing an optimizer loop, creating eval plans, collecting player artifacts, reconstructing replay data, generating hypotheses, testing policy changes, or deciding whether an improvement is real.

Run an autonomous policy optimization loop: monitor leaderboard changes, select opponents, launch evals, analyze artifacts, create hypotheses, test candidates, and promote only verified improvements. Use for continuous or scheduled optimization of game policies.

Coworld operations guide for optimizer agents. Use when reading leaderboards, memberships, submissions, creating or polling XP/experience requests, downloading replays/artifacts, uploading policy images, submitting policies to leagues, or checking active player/auth state.

Use to tune crewborg's crewmate-side social-deduction surface — the Bayesian P(imposter) suspicion model, its per-event likelihood-ratio functions, the state-dependent vote bar, and the measured opponent chat tells — by fitting weights from labelled replays. Trigger on 'tune suspicion', 'improve voting / meeting decisions', 'fit the LR functions', 'mine opponent chat tells', 'why did crewborg vote wrong', or 'optimize crewmate win rate'.

Decide what a policy should log to validate a specific hypothesis, then instrument it so the next eval's artifacts carry the signal — pick the minimum signals, the cheapest artifact home (event/position/metric), keep it joinable to the ground-truth clock, choose a cost-aware trace level, emit at the right seam, and smoke-verify before the big eval. Use when the current artifacts cannot distinguish a hypothesis from the null.

Aggregate an eval set of episodes (player artifacts + replays) into a trustworthy verdict on the goal metric — filter taint first, aggregate per role and per version, report effect size with uncertainty, weight by the scoring objective, and run the anomaly trust gate before calling a result real. Use to decide whether a policy change is statistically better, not just numerically different.

Design an eval set whose variance configuration is chosen for a specific optimization goal — opponent field, seat/role rotation, episode count, seeds — and state the trust bar (large enough N, taint filtering, identical config on both arms) before reading results. Use when deciding how many episodes, which opponents to eval against, or how to make an eval actually measure the goal.

Create, monitor, and archive hosted experience request evaluations for policy-vs-policy testing. Use when running XP requests, pairwise evals, top-N/random evals, or downloading hosted episode replays and artifacts.

Navigation techniques for scripted policies that move an agent through a map — building a nav graph over a walkability grid, A* with line-of-sight smoothing, clearance margins, destination anchors, special edges (teleports/portals/vents), reachability checks, momentum/bang-bang motion control with predictive stop, route re-rooting, and stuck detection/recovery. Use when a policy must reach points on a map and pathing/arrival is a failure source.

Infer opponent policy strategies from eval results, replays, prompts, answers, artifacts, and leaderboard changes. Use to detect copied strategies, attractors, seat conditioning, and strategy shifts.

Guide for utilizing player artifacts in Coworld policies and optimization loops. Use when adding artifact emission to a policy, downloading artifacts from evals, joining artifact data with replays, or building analysis datasets from episode evidence.

Generate and test policy improvement hypotheses from eval evidence. Use when deciding what code or strategy change to make after analyzing replays and opponent behavior.

Decide whether a candidate policy is safe to promote or submit. Use after evals to compare champion vs candidate with variance, target coverage, broad guardrails, and rollback criteria.

Reconstruct game behavior from hosted replays and persistent player artifacts. Use to aggregate XP evals, identify role leaks, inspect prompts/answers/actions, and build debugging datasets.

Turn a corpus of real scored episodes into a RANKED list of testable, VP-quantified hypotheses by finding the behaviors that explain a policy's own score variance. Use after any multi-episode eval to decide what to change next, instead of eyeballing replays or guessing. Distinguishes load-bearing finishing moves from the invariant engine.

Techniques for building a robust scripted control path for a policy so it plays every step deterministically, never crashes, falls back instantly when an LLM is slow or fails, resumes mid-game from live state, and survives opponent message/broadcast storms. Use when a policy is fragile under provider failure or load, times out, replays stale state, over-sends actions, or needs a non-LLM path that supports every phase of the game.

Analyze map/positional policy data spatially and temporally so behavior patterns become visible, and generate after-the-fact visualizations (heatmaps, trajectory polylines, event-anchored windows, timelines, encounter geometry) for pattern mining and hypotheses. Use for games with maps, movement, line of sight, phases, or any spatial/temporal structure, or when a flat table hides the pattern you need.

Use to save, download, and read crewborg player artifacts (per-episode trace.db + summary.json) for the optimizer loop. Trigger on 'save player artifacts', 'get crewborg's logging', 'where is the trace.db', 'download artifacts', or 'read the episode artifact'.

Use to decide what crewborg should log to validate a specific hypothesis, then instrument the policy so the next eval's artifacts carry the signal. Trigger on 'what data do I need', 'how do I instrument this', 'what should I log to test this', or 'add tracing to validate the hypothesis'.

Use to correctly aggregate a crewborg eval set of player artifacts + game replays into win rates, effect sizes with uncertainty, and to run anomaly checks before trusting the result. Trigger on 'aggregate the eval', 'is this change statistically better', 'compute win rates', 'did it actually improve', or 'are these eval results trustworthy'.

Use to design and run a crewborg eval set whose variance config is chosen for a specific optimization goal: opponent field, seat rotation, episode count, seeds, and the trust requirements (large N, taint filtering). Trigger on 'run an eval set', 'how many episodes', 'which opponents to eval against', or 'design the eval for <goal>'.

Use to turn a crewborg behavior pattern into a falsifiable, pre-registered improvement hypothesis with a predicted metric move, for the optimizer loop. Trigger on 'generate a hypothesis', 'why is this happening', 'what change should I try', or 'turn this pattern into an experiment'.

Use to run the crewborg policy optimization + eval loop: run eval sets, find behavior patterns, generate hypotheses, instrument + change the policy, and re-evaluate against an optimization goal. Trigger on 'optimize the policy', 'improve crewborg', 'run the eval loop', 'why is crewborg losing', or 'iterate on the policy for <goal>'.

Use to shape crewborg eval data so a behavior pattern becomes recognizable: heuristics, cheesy patterns, and after-the-fact visualizations (grids/heatmaps/timelines) fed back into the LLM. Trigger on 'find patterns', 'visualize the behavior', 'make a heatmap', 'what is crewborg doing wrong', or 'shape the data so I can see the pattern'.

Use to reconstruct ground-truth game info from a Crewrift .bitreplay and match it to crewborg's player behavioral data so a hypothesis can be validated. Trigger on 'reconstruct the game from the replay', 'join trace to replay', 'expand the replay', 'who actually killed whom', or 'match player data to ground truth'.