Ryuu's Skills

Configuration

The environment variables the installer, the hooks and the skills read.

Installer

Prerequisites: git, gh and Bun 1.4.0 or newer. Installing needs no Python.

install.sh bootstraps skills install, which reads these variables. Paths default under your home directory. Prompts run only with no flags other than --verbose, terminal stdin and stdout, and CI unset. Delivery mode and optional skills also work non-interactively with --with and --without. The arm roster works non-interactively with --arms, and the auto update choice with --auto-update. At a terminal the output is one row per tool with what changed and anything that needs a look; --verbose lists every line. Redirected output keeps one line per item and prints every block in full.

VariableDefaultWhat it does
AGENTS_DIR~/.agents/skillsThe canonical store the skills are linked into. All four hook commands run the CLI through its playbook link.
CLAUDE_HOME$CLAUDE_CONFIG_DIR, else ~/.claudeWhere agents are copied, the parent of the Claude Code skills directory, and where retired hook copies are checked. Settings follow CLAUDE_CONFIG_DIR, else ~/.claude, independently of this variable. When it points elsewhere, every run prints a warn line.
CODEX_HOME~/.codexWhere missing skills entries are added to hooks.json.
SKILLS_CONF~/.agents/skills.confWhere the delivery mode and optional skills are saved. SessionStart, the commit guard and skills publish read it in the CLI; the remaining delivery scripts use skills delivery. It must be absolute: the installer refuses a relative path, and every reader treats one as hands-off.
SEED_DIRS$CLAUDE_HOME/skills and ~/.codex/skillsSpace separated skills directories, each created when its parent directory exists. The Codex entry stays ~/.codex even when CODEX_HOME is set.
EXTRA_DIRS~/.cursor/skills, ~/.config/opencode/skills and ~/.copilot/skillsSpace separated skills directories that get links only when they already exist.

Rule Levels

Set AGENT_RULES in ~/.agents/skills.conf to manage Claude Code permission rules, the Codex rules file and the OpenCode rule groups on each install run. When the Claude Code, Codex or OpenCode directory exists, the interactive installer sets it through the Deny, Ask, Customize or Don't manage prompt. Customize saves per-group overrides. Choosing Deny or Ask clears those overrides. Don't manage lets you remove owned entries or leave them in place. The delivery mode selects the recommended set.

KeyValueWhat it does
AGENT_RULESdenyUses the set's recommended placements.
AGENT_RULESaskTurns recommended deny placements into ask.
AGENT_RULESoffRecommends no rules unless a group override enables them.
AGENT_RULESunsetLeaves rules unmanaged and names the reason; --verbose prints the set.

Each per-group key overrides the global level. Its suffix is the group id uppercased, with dashes replaced by underscores. Overrides need AGENT_RULES set. Invalid values are noted and skipped.

skills.conf keygroupallowed
AGENT_RULES_MERGEMerge a PRdeny, ask, off
AGENT_RULES_FORCE_PUSHForce or mirror pushdeny, ask, off
AGENT_RULES_PR_REVIEWReview a PRdeny, ask, off
AGENT_RULES_ISSUE_COMMENTComment on an issuedeny, ask, off
AGENT_RULES_PR_COMMENTComment on a PRdeny, ask, off
AGENT_RULES_SKILLS_CONFEdit skills.confdeny, ask, off
AGENT_RULES_INSTALLERRerun the installerdeny, ask, off
AGENT_RULES_CLAUDE_SETTINGSEdit Claude settingsdeny, ask, off
AGENT_RULES_SKILLS_GIT_CONFIGSet a skills git config valuedeny, ask, off
AGENT_RULES_PUBLISHINGCommit, push or open a PRdeny, ask, off
AGENT_RULES_SKILLS_CLIRun skills CLI verbs that publish nothingallow, off

The installer writes strengthening and neutral changes under permissions in Claude Code's settings.json (in CLAUDE_CONFIG_DIR, else ~/.claude). Only entries owned by the rule table change. Formatting can be normalised to the file's indent unit. Each changed group gets a rules line.

Removing a live deny or ask, moving deny to ask, adding an allow, or rewriting an entry whose placeholder path moved weakens the rules. At a terminal the installer lists changes for you to confirm under Add, Update and Remove, one line per group, all ticked. An interactive install lists every change, a run with flags each group with a weakening change. A group you untick is saved as its override: the placement your file holds for an update when that placement settles the group, off otherwise. Choosing Deny or Ask at the rules level prompt clears these overrides like any other. Non-terminal runs leave weakening changes on a left line for you to apply by hand. A group at off whose entries block what the mode needs gets one note line on every run, naming how to lift it. Removing a retired entry is neutral and is applied. If the file is refused, it prints the set and the reason instead. The installer writes Claude hooks before planning rules and prints their block only on refusal. Deny Rules covers ask's limits and commit guard wiring.

Claude hook declines

CLAUDE_HOOK_<TARGET>=off in skills.conf prevents adding or replacing that Claude hook. Targets are SESSION_START, PRE_TOOL_USE, POST_TOOL_USE and STOP. Unticking a hook in the drift prompt saves this key. Delete the line to re-enable it. The key does not remove a skills command already in settings or affect Codex hooks. Hooks are managed independently of AGENT_RULES.

Auto Update

AUTO_UPDATE in skills.conf decides whether skills moves its checkout to new releases on its own. The installer asks right after the delivery mode, preselecting the saved value, or notify when the key is unset or holds anything else. An install from before the key existed asks on its next interactive run.

ValueWhat it does
offNever checks for releases.
notifyChecks daily and says when a release is out, for you to run skills update.
onInstalls each release as skills update would, so that release's code then runs in every hook without asking.
unset or any other valueBehaves as off.

--auto-update off|notify|on or --auto-update=<value> saves the choice without a prompt and keeps every other line. Empty or repeated flags are usage errors, and any other value fails before the installer writes anything. A run that does not prompt and finds the key unset or invalid leaves it alone and prints one note line naming the key and how to choose. When the key is set more than once, the last line counts, and the next choice you save keeps one line. SKILLS_AUTO_UPDATE=0 in the environment refuses every update whatever the key holds, skills update run by hand included.

The daily run starts from the session start hook, in the background, and its result shows on the next session start. While the key is unset, a session start says so at most once a day. Session brief lists each notice.

./install.sh --auto-update notify

Fast Mode

Two optional lines in skills.conf turn on fast mode per provider. Both default to no. skills fast-mode prints the value each one resolves to, with a note for a bad or repeated line.

CODEX_FAST_MODE=yes
CLAUDE_FAST_MODE=yes
KeyWhat it does
CODEX_FAST_MODERuns every Codex arm on the priority service tier, through the Codex CLI or a harness such as T3 Code. With no, arms pin the default tier, since some models default to priority.
CLAUDE_FAST_MODERuns a Claude arm in fast mode when a harness can, such as T3 Code's delegate_task for a model that lists a fastMode option. The Task tool has no switch for it, so a Task subagent runs however the session runs.

Wave Threads

/plans wave starts one thread per ready plan in T3 Code. Two optional lines in skills.conf pick the model and effort those threads run at. Without them, each thread runs at the model and effort of the thread that started the wave. skills plans wave <Project> prints the values they resolve to and writes nothing, with a note for a bad or repeated line.

PLANS_WAVE_MODEL=claudeAgent/claude-opus-5-5
PLANS_WAVE_EFFORT=medium
KeyWhat it does
PLANS_WAVE_MODELThe provider instance and model, as <instance>/<model id>, that T3 Code's orchestrator_capabilities lists.
PLANS_WAVE_EFFORTAn effort the chosen model lists. A value the model does not list stops the wave before any thread starts.

Fast mode for a wave thread follows CLAUDE_FAST_MODE or CODEX_FAST_MODE by the thread's provider.

Arm Roster

ARMS_ROSTER in skills.conf selects the arm families for delegated work. Without the key, the default is Claude and Codex. OpenCode is opt in. The installer asks for the roster after optional skills and reviewers, before rule levels, and keeps the saved choices on reruns. Non-terminal runs leave the roster unchanged unless you pass --arms.

The value is a space-separated list of claude, codex, opencode and <tier>=<provider/model>[#variant] tokens. Tiers are luna, terra, sol and astra. OpenCode requires a sol model. Other tiers are optional. A missing tier takes the nearest configured tier above it, but astra serves critical work only. Tier tokens require opencode in the roster.

ARMS_ROSTER=claude opencode terra=opencode-go/glm-5.3#high sol=opencode-go/kimi-k3#max

--arms <value> or --arms=<value> replaces the whole roster and skips the roster questions. At a terminal the installer can still ask you to confirm weakening rule changes. Empty or repeated flags are usage errors. OpenCode choices must match the local opencode models and opencode api model.list catalog. Invalid choices fail before the installer writes anything.

./install.sh --arms "claude codex"
./install.sh --arms "claude opencode sol=opencode-go/kimi-k3#max"

skills arms prints one line per chosen family, including whether its CLI is on PATH. It prints only explicitly configured OpenCode tiers, in luna terra sol astra order. A last line names who writes the code. For example:

claude cli=yes
opencode cli=yes terra=opencode-go/glm-5.3#high sol=opencode-go/kimi-k3#max
implementation=lead

Malformed saved tokens are skipped with arms: notes on stderr. A repeated key uses its first row. Without opencode on PATH, the interactive option is disabled and any saved OpenCode choices stay unchanged. A catalog read failure, or a catalog command that runs past 15 seconds, also keeps saved OpenCode choices. A malformed line elsewhere in skills.conf does not change the roster skills arms reads.

Implementation Arm

The lead agent writes the code, and the review arm reads the diff before it ships. ARMS_IMPLEMENTATION in skills.conf hands every implementation to an arm instead. The value is lead, the default, or a family the roster chooses, codex or opencode. The arm takes the tier the route names for the work.

ARMS_IMPLEMENTATION=codex

A value outside those three, or a family the roster leaves out, keeps the lead writing and prints an arms: note. The installer does not ask for this key.

PR Body

By default skills publish opens every PR with an empty description and leaves the body to the review bot. PR_BODY=agent lets the agent write it instead. The agent writes two to four sentences of plain prose to a file, and skills publish --body <file> sets it as the description of a new PR, or in place of the body gh stack submit generated on a stack layer.

PR_BODY=agent

The key can be set in two places. The skills.conf line applies on this machine. skills.pr-body in a repository's local git config applies to that repository, and when it holds a valid value it wins over the skills.conf line.

git config --local skills.pr-body agent
ValueWhat skills publish does
agentRequires --body <file> and refuses without it. Sets the file as the body when the PR has none, has the repository's PR template, or has the body gh stack generated.
offOpens the PR with an empty body. --body is a usage error.
unsetBehaves as off. A value outside off and agent is skipped, so the other place decides, or off when neither holds a valid value.

A body someone already wrote is never replaced: publish keeps it and prints kept the existing body on stderr. So a rerun after a failed run keeps the body an earlier run already set. Before any commit or push, publish runs the same check skills review reply runs, and refuses a body that names a plan id, mentions an installed reviewer's handle, holds a path under a home directory, or holds a secret. Agents never write either setting: the commit guard blocks a git config command that names a skills. key.

Agent Disclosure

AGENT_DISCLOSURE=on makes the text an agent posts to GitHub as your account say so. Each reply skills review reply posts in a reviewer thread, and each PR body skills publish --body <file> sets, then starts with this sentence and a blank line:

An agent posted this on behalf of this account.
AGENT_DISCLOSURE=on

The key can be set in two places. The skills.conf line applies on this machine. skills.agent-disclosure in a repository's local git config applies to that repository, and when it holds a valid value it wins over the skills.conf line.

git config --local skills.agent-disclosure on
ValueWhat skills review reply and skills publish do
onPut the sentence and a blank line before the reply or the agent PR body.
offPost the text as written.
unsetBehaves as off. A value outside off and on is skipped, so the other place decides, or off when neither holds a valid value.

The key changes what gets posted, never whether: a reply still needs prs mode and an active reviewer, and a PR body still needs PR_BODY=agent. The outgoing text check reads the text before the sentence goes on. A reply already in the thread counts as the answer with or without the sentence, so a rerun after a failed resolve posts nothing, and neither does a thread answered before you turned the key on. Agents never write either setting: the commit guard blocks a git config command that names a skills. key.

Reviewer Roles

Each reviewer's role is required or advisory, and Roles says what each one does to a PR. It is read from three layers, and the last valid value wins:

  1. The default in the reviewer's own reviewer.conf.
  2. <REVIEWER>_ROLE in skills.conf, for every repo on this machine.
  3. skills.<reviewer>.role in a repo's local git config, for that repo alone.
CODERABBIT_ROLE=advisory
git config --local skills.coderabbit.role advisory

skills settings <reviewer> prints the role that applies in the current repo. A value other than required or advisory is skipped with a note and leaves the layer below it in place. Agents never write either layer above the default.

Audit Digest

AUDIT_DIGEST=weekly in skills.conf lets /plans schedule register one task per machine in T3 Code's scheduler. Every Monday at 09:00 it opens a fresh thread that runs skills audit --days 7 --prs --digest and posts the output. The thread stays in your active list until you read it. Without the key, /plans schedule registers nothing.

AUDIT_DIGEST=weekly

--digest saves the run as <plans>/audit/<repository>/<UTC date>.json, the repository being the main checkout's folder name, and compares it with that repository's newest saved run from an earlier date. skills audit --compare <old.json> <new.json> prints the same comparison for any two saved runs. With only <old.json> it compares against a fresh run. Each field line starts with flag, ok, new or gone, and the newer run's notes follow as Note: lines, so a source that failed to read is named. Higher is worse for every field. A time or count is flagged at a 25% rise or more, a share at 5 percentage points or more, and a field missing or zero in the old run prints as new unless it is still zero. --compare takes no --json.

Weekly Digest

DIGEST_WEEKLY in skills.conf lets /plans schedule register one task per machine in T3 Code's scheduler. Every Monday at 09:00 it opens a fresh thread that runs skills digest for the week just finished, which the dashboard's digests view then shows, and the thread settles itself unless the verb failed. Dashboard describes the digest.

KeyValueWhat it does
DIGEST_WEEKLYonRegisters the Monday task.
DIGEST_WEEKLYunsetRegisters nothing.
DIGEST_WEEKLY<any>Registers nothing, and skills plans schedule prints the value it refused.
DIGEST_WEEKLY=on

Stalled Threads

PLANS_RESUME_EVERY=<n>m in skills.conf lets /plans schedule register one task per project in T3 Code's scheduler. Every <n> minutes it opens a fresh thread that runs /plans resume, which sends each stalled DOING thread one message naming the cause and asking it to carry on. A thread is stalled when no turn is running and its last turn ended at neither a handback nor a question to you.

PLANS_RESUME_EVERY=20m
CauseWhen it nudges
rate-limitThe last turn ended on a usage limit, and its reset time has passed when the thread names one.
restartThe last turn ended on T3 Code's restart notice that cancelled background work.
unknownThe thread has been idle 20 minutes for no reason above.

A thread that is running, waiting on its own background work (for up to two hours), asking you something, handed back, or stopped or cancelled is left alone. Each stall gets at most one message and a row at most one an hour. A row nudged three times for idle time with no other trail event between is left for you, while a usage limit keeps its hourly retry until it clears. Each message sent adds a nudge <cause> <run> line to the plans trail. skills plans resume <Project> prints off and the task does nothing while the key is unset or invalid, so removing the line stops it without touching the scheduler.

THREADS_RESUME_EVERY=<n>m does the same for ad hoc threads, the ones that opened a PR through skills publish with no plan behind it. /plans schedule registers one threads resume <repo> task per project, in any repository, one with no plans project included. Every <n> minutes it runs /plans threads resume, which finds each thread through T3 Code's link to its PR and nudges it when its branch still carries the publish mark, its PR is open, and its last ad hoc trail line is start. The causes, the skips and the limits are the ones above, counted per branch from its own nudge trail lines. skills threads resume prints off while the key is unset or invalid.

THREADS_RESUME_EVERY=20m

Merged Plans

PLANS_SWEEP_EVERY=<n> in skills.conf, in whole minutes and at least 5, lets /plans schedule register one task per project in T3 Code's scheduler. Every <n> minutes it opens a fresh thread that runs /plans close with no id, which closes each plan whose PR merged and sends each conflicting PR a fix round. The thread settles itself unless a close refused, so a run that finds nothing leaves nothing in your active list. Without the key, /plans schedule registers no sweep task. skills plans schedule <Project> prints each task it would register, or why it is off.

PLANS_SWEEP_EVERY=30

Released Checkouts

skills plans release <Project> removes the linked checkout of a closed plan once nothing in it would be lost: no uncommitted change, no commit outside its PR on GitHub, no process working in it, and no ignored path it cannot rebuild. Commits are checked against the head of the PR merged into the default branch, or when none merged there, the head of the branch's newest PR, open or closed. The branch stays, so a harness can recreate the checkout from it. Ignored paths named node_modules, .expo, expo-env.d.ts, .cache, .turbo, dist, .next, next-env.d.ts, coverage, .source or .tanstack count as disposable. PLANS_DISPOSABLE in skills.conf adds more names, separated by spaces on one line, each matched against the last segment of an ignored path. A name starting with .env never counts, whatever the key says, and one inside a disposable directory other than node_modules holds the checkout too. Setting the key on a second line holds every checkout and makes the run exit 1. skills plans release <Project> --dry-run prints what it would release and removes nothing. skills plans release <Project> --facts reads a JSON array of {"path": "<checkout>", "live": <bool>} entries on stdin and keeps every checkout that has no single valid entry with "live": false, so a checkout a harness still works in survives.

PLANS_DISPOSABLE=android ios .gradle

Hub

The hub reads two keys, from the environment first, then skills.conf. An empty value counts as unset, and an empty one in the environment still hides the one in skills.conf. ./install.sh --with hub writes both, --hub-url and --hub-network set them without prompts, and --without hub removes them.

KeyDefaultWhat it does
HUB_URLunsetThe hub's root URL, with no path, query or credentials. Unset, nothing syncs, skills hub status prints no hub configured, and the other hub verbs that need it refuse with no HUB_URL, set it in the environment or skills.conf. skills hub init and skills hub recover take the URL as an argument instead.
HUB_NETWORKpublicpublic, tailscale or local. public and tailscale take only https:// with a trusted certificate, and local also takes http:// to a private address. Network Modes has the rules.
HUB_URL=https://skills-hub.example.ts.net
HUB_NETWORK=tailscale

HUB_KEYS=file, read from the environment only, keeps the device keys in files under ~/.agents/hub/ instead of the macOS login keychain. Elsewhere they are files already.

Hooks and Skills

VariableDefaultWhat it does
PLANS_DIR~/PlansWhere plans, the trail and the store, plans.db, live. The plans skill, its verbs and the session brief read it.
AGENT_HOOKS1Set to 0 to turn the hooks off. The commit guard keeps enforcing the delivery mode and skips only its comment sweep.
AGENT_HOOKS_SKIPvendored and generated dirsComma separated path fragments the comment, dash and reply guard hooks skip. A value replaces the defaults rather than adding to them.

The AGENT_HOOKS_SKIP defaults are node_modules/, /.git/, /dist/, /build/, /out/, /target/, /vendor/, /generated/, /.venv/, /_archive/ and /done/. An empty value uses them too.

On this page