sophia-agi

Use for finance and macro calculations done inside a spreadsheet: value-at-risk / reserves-at-risk on reserve holdings, price-return volatility and its annualisation, net exports as a share of GDP, GDP-weighted averages, spreadsheet statistics (min/max/median/percentile), and recovering missing figures in a linked financial workbook. Fires on "reserves at risk", "value at risk", "volatility", "net exports % of GDP", "weighted mean / SUMPRODUCT", "percentile", or "fill in the missing values from the totals/shares". Carries the exact formulas and the Excel percentile interpolation a grader checks.

Use when a task's answer is an .xlsx workbook that will be graded by a script, especially when the grader reads cells with openpyxl or converts the sheet to CSV. Fires on "write Excel formulas", "keep the formulas in the file", "no hardcoded values", "use openpyxl / xlsxwriter", "the cell must start with =", "recalculate the workbook", or a checker that reads a specific cell address. Covers the choice between emitting a live `=` formula and a literal value, why openpyxl formulas read back as None, the `_xlfn.` prefix, cross-sheet quoting, and the file-integrity rules graders enforce.

Use when modelling the macroeconomic impact of an investment spending shock in a spreadsheet — either the demand-side national-accounting framework (multiplier, import leakage, project allocation) or the supply-side Cobb-Douglas potential-GDP framework (TFP, HP-filtered trend, capital accumulation). Fires on "investment shock", "demand multiplier", "import content share", "supply-use table", "potential GDP", "Cobb-Douglas", "HP filter", "TFP / Solow residual", "extend the growth projection", or "capital accumulation with depreciation". Carries the exact in-sheet formula chain each model uses.

Use when the deliverable is a COUNT, RATE or AVERAGE computed from a repository's pull requests and issues over a date window, gathered with the `gh` CLI or the GitHub REST/GraphQL API — "how many PRs were opened in December", "average time to merge in days", "who opened the most PRs", "how many bug issues were closed that month", a monthly community-pulse report. Fires on "gh pr list", "gh issue list", "gh api", "repo analytics", or a JSON activity report checked against exact numbers. Carries the pagination defaults that silently truncate the answer, the PR/issue state semantics, and the two distinct date windows.

Use when the deliverable is a filled-in or edited PDF whose *text* will be checked — a court or government form, an application, a waiver, an intake sheet — or a PDF from which an identifier must be removed. Fires on "fill out this PDF form", "check the Yes/No boxes", "redact the ID / show only the last four digits", "sign and date the form", or a checker that runs `pdftotext` or `pypdf` over the output. Covers AcroForm vs XFA detection, why copying pages destroys the fields, radio and checkbox option values, and text-layer redaction that actually removes text.

Use when computing a powerlifting Dots score (also called Dots coefficient) for one or many lifters, in a spreadsheet or in code — anything that asks for "Dots", "IPF Dots", "Dots coefficient", or a bodyweight-normalised strength score from a squat/bench/deadlift total. Fires when a Total and a bodyweight must be turned into a comparable score across sexes and weight classes. Carries the exact sex-specific quartic coefficients, the asymmetric bodyweight clamps, and the rounding and formula shape a grader checks.

Use when writing or reviewing code that touches a dangerous API surface: `eval`/`exec`/`compile` on a string; `subprocess`/`os.system`/`os.popen` with a shell or a partial path; building a shell or SQL command by string concatenation or f-string; `pickle`/`yaml.load`/`torch.load`/ `tarfile.extractall`/`zipfile.extractall` on data you did not produce; fetching a caller-supplied URL or fetching without a timeout; `md5`/`sha1` in a security decision; a hardcoded `/tmp/...` path; a `0.0.0.0` bind; `chmod 0o777`; `random` for a token or secret; or logging an object that carries a credential. Gives the exact safe replacement call for each surface, plus the three rules that make a redaction survive static taint analysis.

Use when writing or repairing a Suricata / Snort-syntax IDS signature that must fire on one specific HTTP request shape and must stay silent on near-miss traffic — a custom exfil pattern, a C2 beacon, a data-theft POST, a suspicious header. Fires on "write a Suricata rule", "update local.rules", "alert with sid:NNNNNNN", "must not false-positive", "run suricata offline against these pcaps", or a rule graded by replaying positive and negative pcaps. Carries sticky-buffer scoping, the parameter-anchoring regex that separates true positives from lookalikes, content byte-escaping, and the offline verification loop.

Use when implementing a feature, fixing a bug, or making failing tests pass — anything whose done-condition is "the tests pass". Fires on "implement X", "add a feature with tests", "make the tests pass", "fix this bug test-first", "red-green-refactor", or any task that ships behavior. The discipline: write the failing test first and watch it fail, make the smallest change that turns it green, refactor only while green — and never weaken an assertion to reach green, because a weakened assertion certifies the bug instead of catching it.

Use when writing, auditing, or trusting a checker that decides whether an answer is correct — a grader, a reward function, an equivalence test, an assertion-based test oracle, a judge. The reflex is to test SOUNDNESS (a wrong answer must never be accepted). This skill forces the other direction, which a soundness test structurally cannot see: COMPLETENESS — is every CORRECT answer accepted? Fires on "is this verifier right", "the pass rate looks too low", "the pass rate is identical across every variant", "compare two answers for equality", "check symbolic/numeric equivalence", or before trusting any score a checker produced.

Use when the answer is a COUNT of distinct physical objects seen in a video or in frames extracted from one — "how many pedestrians walk through this clip", "how many coins are on screen in each keyframe", "count the vehicles in each file and write the number". Fires on "count the same object across frames only once", "don't count a person appearing in multiple frames as multiple people", "per-keyframe object counts", or "template matching count". Carries the frame-sampling cadence, the detector arguments, the within-frame de-duplication rule, and the across-frame aggregation that turns per-frame detections into a distinct-object count.

Run BEFORE committing or pushing; a handover, ledger, pointer, index, or artifact drift — or a red no-overclaim gate — is the usual reason a PR in this repo goes red, not a real bug. (Trigger note: the skill index derives its keyword list from the FIRST 12 non-stopword tokens of this description — `_triggers_from_text(limit=12)` — so any drift source that must auto-fire the skill has to be named in THAT opening sentence, not further down. That is exactly how the handover drift source stayed invisible to the trigger while being documented in the body.) Concretely, PRs go red on (a) generated artifacts that drifted from their source of truth (RESULTS.md, the RAG index, wiki pages, the local-Sophia dataset, the version stamp, the failure ledger, and the SESSION-HANDOVER -> CURRENT.json -> Agent-Index chain) and (b) the no-overclaim measurement gates (lint_claims, claim_gate, eval_stats, assert_decontam, lint_training_rows). Use to regenerate/verify these locally so the PR lands green the first time. ALSO fires t

Run the MOMENT a CI check goes red in this repo, and BEFORE any push that could reintroduce a known failure. Fires on: a failed `test-shard`, `fast`, `ci-complete`, `guard`, `validate-*`, `codeql`, `secret-scan`, or `deps-audit` check; "CI error", "CI failed", "the build is red", "fix the failing check", "why did CI break", "/ci-failure-catalog". This is the LIVING catalog of every CI failure this repo has hit + its root cause + the exact fix — a growing playbook, not a static doc. It ROUTES to the specialised skills (ci-artifact-drift, ci-script-test-bootstrap, git-discipline §3/§3a, spark-selfhosted-runner) and catalogs everything else. **Every session that hits a CI failure not already listed MUST append a row after fixing it** (the append protocol below) — that is what keeps this skill useful.

Run BEFORE writing a CUDA/Triton kernel, adopting a GPU library, or optimizing slow training/benchmark/eval throughput — routes the work to the lever that actually pays on this fleet. Fires on "speed up training", "the training is slow", "write a CUDA kernel", "Triton kernel", "GPU-accelerate this", "make the eval faster", "optimize throughput", "use CUDA", "fuse this op", "should this run on the GPU", "the benchmark takes forever", or any plan whose first move is to write a kernel. Also fires when a session proposes FP8/MXFP4 training on the Spark, flash-attn on sm_121, GPU vector search / GPU dedup for the RAG corpus, Muon for fine-tuning, or Unsloth — each is a REFUTED lever with a specific refuting fact below, and re-attempting one is the exact repeat-waste this skill exists to stop. Applies to the DGX Spark (GB10/sm_121/aarch64), the RTX PRO 6000 (sm_120/x86), RunPod pods, and the Mac MLX boxes.

Run BEFORE any git write (commit, push, merge) and before a stale checkout or branch read: exists? landed? — in this multi-agent repo the filesystem answers for someone else's branch, not yours, so `git show origin/main:<path>` is the only honest answer to "does X exist / did Y land". (Trigger note: this index derives keywords from the FIRST 12 non-stopword tokens of this description — `_triggers_from_text(limit=12)` — so the read-side terms above MUST stay in this opening sentence; when they weren't, this skill could only fire on writes while the trap fires on a READ, and it took three victims in one hour.) The full write surface still applies: commit, push, branch, switch, rebase, merge, open/close/merge a PR, re-trigger CI, "unblock #NNN", or diagnose a failing CI check, a "superseded/divergent" branch, or a "CI seems stuck" / green-but-won't-merge PR (decode mergeable_state FIRST — see §3a), a DIRTY/CONFLICTING mergeable_state stuck on a stale GitHub cache even when merge-base --is-ancestor + merge-tree p

Run BEFORE you write to any of this repo's append-heavy shared files — agi-proof/failure-ledger.md, agi-proof/evidence-manifest.json, RESULTS.md, or the live SESSION-COORDINATION.md — and whenever a task adds/edits a failure-ledger row, records a NO-GO/candidate result, claims/releases work in the coordination ledger, or regenerates the evidence manifest. These files are touched concurrently by many Codex/Copilot/GLM/human sessions on ONE checkout; two sessions hand-editing the same one collide, a bad Status string silently flips OPEN→resolved, and a stale manifest fails CI. Use even if the edit "looks like one line".

Use at the START of a session to bootstrap from the previous session's state, and at the END of a substantial session (or when the user says "hand over", "wrap up", "write a handover", "what's the state for the next session", or work spans devices/agents). This repo's continuity runs on a chain of handover docs (SESSION-HANDOVER-*.md, HANDOVER.md) plus the failure ledger; reading the newest one first prevents redoing finished work, and writing one at the end keeps the next Codex/Copilot/GLM/human session from starting blind.

Run when a Claude-Code-on-the-web / remote-container session hits harness or environment outages: Bash (or non-GitHub MCP tools) erroring with "temporarily unavailable / cannot determine the safety of Bash right now", git-crypt missing ("git-crypt: command not found"), encrypted skills arriving as ciphertext, or a push that must happen while local shell is down. Use even if the outage "should be brief" — these fallbacks keep the whole session productive instead of stalled, and they have repo-specific traps (never-stage files, post-API-push resync).

Use at the START of a session to bootstrap from the previous session's state, and at the END of a substantial session (or when the user says "hand over", "wrap up", "write a handover", "what's the state for the next session", or work spans devices/agents). This repo's continuity runs on a chain of handover docs (SESSION-HANDOVER-*.md, HANDOVER.md) plus the failure ledger; reading the newest one first prevents redoing finished work, and writing one at the end keeps the next Claude/Copilot/GLM/human session from starting blind.

Run BEFORE you write to any of this repo's append-heavy shared files — agi-proof/failure-ledger.md, agi-proof/evidence-manifest.json, RESULTS.md, or the live SESSION-COORDINATION.md — and whenever a task adds/edits a failure-ledger row, records a NO-GO/candidate result, claims/releases work in the coordination ledger, or regenerates the evidence manifest. These files are touched concurrently by many Claude/Copilot/GLM/human sessions on ONE checkout; two sessions hand-editing the same one collide, a bad Status string silently flips OPEN→resolved, and a stale manifest fails CI. Use even if the edit "looks like one line".

Run BEFORE fine-tuning ANY Mixture-of-Experts model (Qwen3-30B-A3B / -A22B, OLMoE, DeepSeek-MoE, any `*-A\d+B` model) on this fleet, and BEFORE dispatching a big-model (≥30B) paid RunPod training lane. Fires on "fine-tune a MoE", "MoE LoRA", "train Qwen3-30B-A3B", "expert routing / target the experts", "--n-cpu-moe / --cpu-moe", "which GPU for a 30B bf16 LoRA", "the RunPod train pod OOMed / disk-quota / got reaped / timed out", or "moe-sft-runpod / spark-moe-sft / mac-mlx-moe-train lane". This repo learned the MoE recipe AND the 30B-paid-lane infra recipe the expensive way (5 paid pods, ~$30, four one-per-pod infra walls) — front-load ALL of it so you do not rediscover it a paid pod at a time. Use even for a "quick" run and even if the 7B lane "already works" — MoE and 30B both break the small-dense defaults. Slash: /moe-finetune-limited-gpu. Augments wisdom-gpu-prebaked (RunPod deps) and spark-cluster-ops (pod cost-guard §5).

Run when auditing or writing a reward/eval verifier — BEFORE you trust a pass rate, a reward signal, or a "the verifier is sound" claim. The reflexive check is for FALSE-ACCEPTS (soundness: a wrong answer must never be accepted). This skill forces the OTHER direction, which soundness gates structurally cannot see: COMPLETENESS — is every CORRECT answer accepted? A correct answer rejected by the verifier (a reward UNDER-count) does not merely mislabel one eval row; in an RL loop it is a training-reward signal that pushes the policy AWAY from correct behavior. An under-count poisons the POLICY, not just the eval. Use this skill to build a fixed known-correct notation battery, run it through every verifier entry point, and gate the correct→accept direction in CI. Triggered by the verifier-integrity-sprint-2026-07-11 finding: the math verifier was LaTeX-blind, under-counted base passAt1 0.5167→1.0, and trained 27 adapters on poisoned reward.

Run BEFORE building anything from a vague, large, or freshly-stated feature ask — the moment the user says "plan this", "before we build", "grill me", "stress-test this idea", "help me think this through", or hands over a one-paragraph description of multi-file work. Use even if the ask looks clear enough to start coding — "clear enough" is exactly the state this interview exists to test, and in this multi-agent repo an unexamined plan burns worktrees, GPU slots, and sibling sessions' time. The output is a de-risked plan plus an explicit assumptions register, produced through a one-question-at-a-time interview. Slash alias: /grill-the-plan.

Run when the user says "implement X", "add a feature with tests", "make the tests pass", "fix this bug test-first", "red-green-refactor", or picks up any ticket whose Verify-by is a test. The discipline: write the FAILING test first and watch it fail, make the smallest change that turns it green, refactor only with tests green — and NEVER weaken an assertion to get to green, which is this repo's no-overclaim rule in miniature. Use even for changes that feel too small to test-drive — "too small to test" is how untested paths accumulate. Slash alias: /tdd-loop.

Run when the user says "write a spec", "turn this into a spec", "spec this out", "write this up so someone else can build it" — or at the natural end of a `/grill-the-plan` session, when decisions have stabilised and need a durable, reviewable form. This is pure synthesis: NO new interviewing, only compaction of what the conversation and the codebase already established. Use even if the discussion feels too small to "deserve" a spec — a half-page spec that a reviewer can reject in one read is cheaper than a wrong implementation. Slash alias: /to-spec.

Run when the user says "break this down", "create tickets", "create issues", "milestone plan", "split this into tasks", or hands over a spec / grilled plan that is too big for one session. It converts a spec into TRACER-BULLET tickets: thin end-to-end slices, each independently verifiable, with explicit blocking edges — never horizontal layers ("all the schema first, then all the logic, then all the tests"). Use even if the work "naturally" splits by layer — that split is precisely the failure mode this skill blocks. Slash alias: /to-tickets.

Run when the work is bigger than one session AND the route is unknown: "this will take multiple sessions", "where do we even start", a large migration, a repo-wide audit, "untangle X across the codebase" — any ask where you cannot yet draw the ticket breakdown because the facts that would shape it are missing. Use even if you feel able to sketch a plan now — a plan drawn before scouting encodes guesses as commitments. The unit of progress here is an INVESTIGATION ticket: a time-boxed scouting task whose deliverable is knowledge (a written finding), which then reshapes the map. Slash alias: /wayfinder.

Run BEFORE writing or reviewing code that touches any of these dangerous surfaces in this repo, and BEFORE responding to a "fix the security issues / CodeQL alerts / secret-scan / code-scanning" request. Fires on: `eval(`/`exec(`/`compile(` on a string; `subprocess`/`os.system`/`os.popen` with a shell or a partial path; building a shell/SQL string with an f-string or `+`; `pickle`/ `yaml.load`/`torch.load`/`tarfile.extractall`/`zipfile.extractall` on untrusted data; `urllib`/ `requests` to a caller-influenced URL or without a timeout; `md5`/`sha1` used for a security decision; `tempfile` via a hardcoded `/tmp/...` path; `0.0.0.0` binds; `os.chmod` 0o777; a literal that looks like a credential; "fix all N security/quality issues", "CodeQL", "bandit", "ruff S". Teaches the SAFE alternative for each, AND the repo's known FALSE-POSITIVE patterns so a session never wastes time on noise or — worse — "fixes" intentional, gated code. No capability claim; `canClaimAGI` stays false.

Run BEFORE launching any GPU job, opening a worktree/cherry-pick on this git-crypt repo, pushing to a shared feature branch, creating or deleting a RunPod pod, or coordinating with peer agents on the sophia-agi cluster (DGX Spark + Mac Studio + RunPod x86 + the bridge serializer). This repo runs 5+ concurrent Claude/Copilot/ops sessions on ONE checkout and ONE shared 128 GB Spark GPU; the local checkout is stale the moment it is read, and a stray heavy GPU load can silently KILL an in-flight cert/train. Use to: pick the right box for a workload, hold the one-GPU-job invariant, recover from git-crypt-broken worktrees, reconcile shared-branch rebases, and avoid the pod-deletion / cost-gate traps. Also fires when a RunPod pod VANISHES (404) mid-run with no crash log, pods "die at random times", a peer sweep reaped your pod, a paid pod idle-reaps during a long model pull, or a benchmark pod leaks a private pack — see §5b. Augments (does not replace) git-discipline, ci-artifact-drift, session-handover.

Run BEFORE any force-push, rebase, branch restart (`checkout -B`), or squash-merge-and-reuse of a branch in this repo — and BEFORE dispatching any SSH-free/self-reporting RunPod lane (open-judge, virtue-evals, independence-eval-v2, long-horizon, wisdom-pilot) — to check whether live pods or workflows are still PUSHING EVIDENCE to that branch. Those pods clone the branch at pod start and push receipt commits back to it; a mid-run history rewrite makes their pushes non-fast-forward, which either times out the launcher (a wasted paid pod-hour) or silently drops the receipts while the Actions run still reports SUCCESS (green-but- resultless). Fires on: "rebase the PR branch", "restart the branch from main", "force-push", "re-use the merged branch", or dispatching a lane whose workflow says "pod self-reports via git push".

Announce an ETA in the chat for ANY task that will not finish before your next message — background bash commands (run_in_background), Workflow runs, subagents (Agent tool), GPU/RunPod dispatches, PR merge-watchers, monitors, model pulls/training, and multi-minute builds. Fires the moment you launch or hand off long-running work, and again on material change or completion. The user runs many parallel agents and is often away from the terminal; a task with no stated ETA reads as "hung." Use whenever you start something you will report back on later.

Run BEFORE bringing a self-hosted GitHub Actions runner online on the DGX Spark, or when a workflow_dispatch GPU job is stuck "queued/waiting" against `[self-hosted, spark, aarch64]`, or when provisioning a model / SUT (e.g. Unlimited-OCR, SGLang) into a venv on the Spark for a `.github/workflows/*.yml` job. Fires on: "register the Spark runner", "runner offline", "self-hosted runner", a workflow step dying `python: command not found` / `exit code 127` at preflight, `pip`/`torch` "externally-managed-environment" (PEP 668), a backend that is NOT on PyPI, or an sglang/vllm wheel that silently clobbers a CUDA torch to `+cpu`. ALSO fires on SGLang refusing to serve a `trust_remote_code` HF model — `"<Arch> has no SGlang implementation and the Transformers implementation is not compatible with SGLang"` — and on the repeated one-dep-per-run "whack-a-mole" where each dispatch dies on the next missing custom-code import (matplotlib, easydict, trust_remote_code). Applies to BOTH the Spark lane and the paid RunPod lane

Run when an RLVR / eval-harness number looks wrong or "too clean" BEFORE you act on it — a 0/N pass rate on BOTH base and adapter, per-seed metrics that won't reconcile across a sweep, a "broken verifier" (passAt1 0/0 or VSC), a PEFT "Target modules {...} not found", or a real uplift recorded as NO-GO. Most of these are MEASUREMENT ARTIFACTS, not capability or idea failures. Use to diagnose the artifact, pick the metric that is actually load-bearing (passAt1 / VSC, not meanReward), pin a multi-seed sweep for comparability, and uphold the no-overclaim rule — the HARNESS is the deliverable; canClaimAGI stays false.

Run BEFORE planning or launching a batch of work in this repo — a train/cert/eval sweep, a multi-PR push, a judge-farm run, or any "let's parallelize this / run these N things" moment, and whenever a queue is backing up, throughput has stalled, GPU/CI/merge is idle-but-blocked, or a measured delta can't be attributed. This cluster has exactly ONE shared Spark GPU, a serialized Mac judge, a human merge gate, and an append-heavy ledger — pushing more work at a saturated constraint only grows queue and mixes variables. Use to find the current constraint, cap work-in-progress at its capacity, subordinate everything else to it, and change ONE variable at a time so deltas stay attributable. The LLM is never the constraint.

Run WHILE a long GPU/train/eval/cert run is in flight and its intermediate signals are in — a first checkpoint's eval, a first-seed passAt1, a live reward/VSC/loss curve, a cert top1/KL, or the moment a number lands that "looks wrong" or "too clean". This repo shares ONE 128 GB Spark GPU across 5+ concurrent sessions, so a run that is already floored, mis-metriced, or measuring a harness artifact is burning a slot every other agent needs. Use to score the trajectory mid-flight, tell a HARNESS ARTIFACT (0/0-both, broken verifier, floored metric) from a real capability failure, and STOP a floor-determined NULL early — without p-hacking it green. Also fires on "should I keep this run going", "the first eval looks off", "is this worth the GPU", "kill it or let it ride".

Run at the human-at-the-PR end-of-line, BEFORE approving/merging or before recommending a merge in this multi-agent repo — and whenever a session reports "N PRs landed", "throughput", "merged per hour", "ready to merge", "gate is green", "training run done", or a benchmark/uplift number. Many concurrent advisors (Claude/Copilot/GLM/human) optimize for merged-PRs-per-hour; this is the feature-factory overclaim trap. This skill re-anchors the merge decision on verified OUTCOMES (real gate receipts, decontam CLEAN, judge-independence not lexical-fallback, canClaimAGI still false) and reasserts that a human holds merge authority. Use even when the PR is green and a prior session already said "safe to merge" — green checks are necessary, not sufficient.

Run at TASK INTAKE — the moment you pick up a ticket/issue in this multi-agent repo and before you touch a file or launch anything. Turns a ticket into a routing decision: build its file/signature dependency DAG, pick a throwaway worktree workcell that won't collide with in-flight work, and pick the right box (Spark GPU / Mac MLX judge / RunPod x86 / pure-CPU). Fires on "start this ticket", "pick up issue #NNN", "where should this run", "can I work on X in parallel", "assign this to a worktree", "route this task", or any hand-off that names files to change plus maybe a GPU/judge step. It is a JUDGMENT recipe that composes existing tools and reads the DAG — it holds NO state.

Run at the START of a recurring, high-friction task in this repo — BEFORE opening a worktree or writing code — whenever the work matches one of the proven shapes this repo repeats weekly: (a) run a pre-registered / gated eval or benchmark, (b) land an evidence artifact (a results row, a gate JSON, a failure-ledger entry) so CI stays green, or (c) resolve a ledger / manifest / results merge conflict. Instead of improvising the scaffold each time, stamp the matching blueprint below, fill the [PLACEHOLDERS], and adapt. Fires on "run the eval", "land the result", "add a ledger entry", "the ledger/manifest won't merge", "regenerate the manifest", "start task X", "/task-blueprint".

Run WHENEVER you are about to open a PR (or push to a shared branch) in this repo after changing code, tools, artifacts, or docs — and whenever you say "let me push this", "open a PR", "it's ready", "fix the failing check", or "wrap up this change". It is the standard per-agent shape before a PR: localize the change, repair, validate the behavior, run the ci-artifact-drift gates + `make claim-check`, resolve review threads for real, and push ONLY gate-green. Sequences this repo's existing deterministic tools so the PR lands green the first time instead of red on drift, an overclaim, or an unresolved thread. Fires even for a "one-line" change — the cheap gates are what keep this high-churn repo landable.

Detect when the current task does NOT match the current git branch, and recommend the right workspace — stay, switch branch, spawn a worktree, or reuse an existing worktree — before any code is written. Then commit, test, and open a PR. Use whenever you start a new piece of work, whenever the task description and the branch name look unrelated, whenever you realize mid-task "I'm on the wrong branch", whenever the current checkout looks contaminated by another advisor's uncommitted work, or before committing to a branch that wasn't created for THIS task. In this multi-agent repo an advisor regularly inherits a checkout left on an unrelated branch (e.g. on `fix/deploy-retry-hardening` while asked to "add a skill") with 20+ uncommitted files from someone else — committing there mixes unrelated work into another advisor's PR. Trigger at the start of every non-trivial task, and again any time the task's intent shifts.