Skip to content
Fito

Action refcard

This card lists every action Fito offers, in the order you run them. It is for a reader who already knows what Fito is and wants the one-page map: a learner, a case creator, a curator or an admin.

It teaches none of them. Every row links to the page that does.

It does not cover Fito’s HTTP API, and it does not cover running a Fito server.

How to read this card

Section titled “How to read this card”

An action is a TUI command you type in a pi session, or a page, control or parameter in the web app. The five phases are an order, not a menu: each one assumes the phase above it.

Every Action cell opens with the surface the action happens on, because a leading / on its own does not say whether a name is a command or an address. The rest of the notation is the same as the TUI command reference uses, and two markers carry the two things that stop a command before it starts:

Notation Meaning
A command you type in a pi session
A page or a control in the web app
<name> A value you supply
[part] Optional
a|b Choose one
... May repeat
?name= A query parameter on a web address
Login Run /fito-login first
Workers Needs the pi-subagents package

Phase 0 — Set up and sign in

Section titled “Phase 0 — Set up and sign in”

Nothing else works until these are done. You install the terminal half once, and you hold two identities: a Fito account, and the GitHub account your submissions come from.

Action What it does Flags and parameters Needs first, and the full page
pi install npm:fito-tui Installs the Fito package for your user, so every pi session, in any folder, offers the /fito- commands None. pi config turns it off without removing it. Remove a clone install of Fito first — with both, pi loads two copies and refuses to start Node.js 24, a pi runtime, git, gh. Install and prerequisites
pi install npm:pi-subagents Installs the worker transport that eleven commands ride. Without it they say Unknown tool: subagent None. It is installed unversioned on purpose, and Fito needs 0.68.0 or newer A pi runtime. Install and prerequisites
Configure an LLM provider in pi Gives the tutor, the scoring and every worker a model to call --provider, --model and --api-key set one session only and win over a stored key A pi runtime. Install and prerequisites
pi update --extensions Installs a newer Fito and a newer pi-subagents. pi says as it starts when a new version is out, and Fito says so when the server refuses your version or your pi-subagents is too old None. Run it in your shell, then start pi again Fito installed from npm. Install and prerequisites
/auth/signup Creates your Fito account from an email address and a password None Nothing. Create an account and sign in
/auth/login Signs you in by password, or by Continue with GitHub. Link GitHub here: the submission artifact is a pull request, so submitting needs it None A Fito account. Create an account and sign in
/fito-login Opens your browser, signs you in, and writes the token pair to ~/.fito/credentials None A Fito account. Log in from the terminal
/fito-auth-refresh Exchanges the stored refresh token for a fresh pair None A terminal login. Log in from the terminal
/fito-logout Revokes the refresh token on the server and deletes the stored credentials None A terminal login. Log in from the terminal

Phase 1 — Create knowledge

Section titled “Phase 1 — Create knowledge”

A case can only be scoped against knowledge that already exists, so this phase comes first. Read what Fito holds, admit the technology, then run the pipeline: ingest, identify, generate, push. Competences come last, because an element is grounded in a live component.

Action What it does Flags and parameters Needs first, and the full page
/knowledge Lists every technology — tools and practices alike — with search, sorting and paging ?q= free text · ?sort=name|component-count · ?page= zero-based Nothing. Browse the knowledge area
/knowledge/<technology> One technology: its version-agnostic description, its major lines, and its component counts per type ?type=concept|execution-fact|usage-scenario Nothing. Technologies, tools and practices
/knowledge/<technology>/<version> One major line, and the components written against it. Every read on the page is scoped to that line ?type=concept|execution-fact|usage-scenario Nothing. Versions and alternative definitions
/knowledge/<type>/<slug> One component in full: its content fields, its revision history, its alternative definitions, and the published cases that use it None. <slug> is the whole dotted id, such as javalin.handler Nothing. Knowledge components
/fito-create-or-update-technology Admits a technology and one of its major lines. A worker drafts the name, kind and prose; a near-duplicate guard stops the run for you to resolve --technology <slug>@<version> required · --source <path> · --fetch · --urls <file> · --docs <path> · --output <path> Login. Workers. Provision a technology
/fito-fetch-urls-content Reads a file of URLs, fetches each page or YouTube transcript, cleans it, and saves it as raw markdown. The fallback input, for a technology with no code to read <URL list file path> required A python3 that can create a virtual environment. Fetch documentation from a URL
/fito-identify-domain-concepts · /fito-identify-execution-facts · /fito-identify-usage-scenarios Read the ingested source and propose candidates, one component type per command. The technology’s kind picks the worker, and no flag chooses it. --source walks a source tree into the bundle they read — there is no ingest command, and a case’s own tree is the preferred input, with fetched documentation the fallback <tool-name> required · --technology-version <slug> required · --technology <slug> · --description "<text>" · --source <path> · --fetch · --urls <file> · --docs <path> · --output <path> The technology and its major line, provisioned. Workers. Identify knowledge components · Ingest a source tree
/fito-generate-domain-concepts · /fito-generate-execution-facts · /fito-generate-usage-scenarios Write each new candidate up in full, against the template the backend holds for that type and kind. Candidates that already exist are skipped. The same ingestion reaches this step only through --identify <tool-name> required · --technology-version <slug>[,<slug>...] required · --technology <slug> · --version <ver> · --concepts, --facts or --scenarios <path> · --output <path> · --mode one|batch|all · --select <items> · --audience beginner|intermediate|advanced · --language <lang> · --identify · --source <path> · --fetch · --urls <file> · --docs <path> A candidate list. Workers. Generate and push components
/fito-push-knowledge Publishes the generated files to Fito, one at a time. A similar or duplicate match stops the run for your choice: link, supersede, skip or create new component [folder-or-files] Login. Generate and push components
/fito-create-or-update-competence Records a competence a technology demands, every element grounded in a live component, or edits one’s name and description --technology <slug>@<version> required · --competence <id> · --output <path> Login, and you own a case or are an admin. Author a competence
/fito-delete-competence Deletes a competence and every sub-competence beneath it, after showing you what would go and asking [<competence-id>] or --technology <slug> — one of the two Login, and you own the competence or are an admin. Author a competence

Phase 2 — Create a case

Section titled “Phase 2 — Create a case”

Design, generate, validate, plan, build, publish. The source code you build yourself, outside Fito, against the plan the fourth step writes.

Action What it does Flags and parameters Needs first, and the full page
/fito-case-design Turns a goal and its declared technologies into a case proposal. Every knowledge reference is verified live, so it refuses an unprovisioned technology and refuses to scope a case whose components do not exist yet "<goal>" required · --technology <slug>@<version> required and repeatable · --source <path> · --output <path> The components the case will teach, already pushed. Design a case
/fito-case-generate Writes the whole .case/ folder — manifest, situation, task, rubric, objectives, prerequisites, starter state, solution notes and an optional quiz — looping edit then validate until the ruleset passes. You can run that same structural ruleset by hand; it prints JSON and exits 0 for a pass, 1 for a failure, 2 for a usage problem [<proposal-path>] · --dir <path> A proposal. Generate the .case/ folder · Validate the .case/ folder
/fito-case-plan-source Writes .authoring/source-spec.md and .authoring/source-plan.md: the self-contained spec and ordered plan for the starter code and the solution branch [<case-dir>] · --scenario reuse|greenfield · --proposal <path> A .case/ folder. Workers. Plan the case source
Build the starter code and the solution branch Hand both documents to your own tooling — a coding agent, or yourself. Fito names none and has no command for this half. .authoring/source-plan.md is the runbook you execute in order; .authoring/source-spec.md is the acceptance criteria you check the result against. Every step carries its own verification command, so a step is done when that command passes, never when the tool reports success None. On greenfield the plan’s first steps scaffold a complete, buildable project from the declared toolchain; on reuse they enumerate changes to the project you already have. Any gap the planner could not trace is named in its digest, for you to close The two planning documents, and the case’s toolchain on your machine. Finished when every rubric gate passes on case/solution-vX.Y.Z, and exactly the tests known_state.yaml names fail on the starter branch. Plan the case source
/fito-publish-case Pushes main, the frozen vX.Y.Z version branch and the solution branch to the case’s repository, then registers and publishes it. One flow serves a first publish and a new version [<case-dir>] · --repo <owner>/<name> · --case-id <uuid> Login. A .case/ tree that validates. Publish a case
/fito-case-edit Clones your own case repository in authoring shape, checks out main, and briefs you on the published version and its last change <case-id> required · --dir <target>, default ~/.fito/authoring/<case-id> A published case. Correct or retire a published case
Retire this case, on /cases/<id> Marks the case deprecated. It leaves discovery, is still served at its own address, and still accepts submissions from learners who already started None Sign-in as the case’s owner or as an admin. Correct or retire a published case
Reinstate this case, on /cases/<id> Moves a retired case back to published, and it returns to every read that hid it. Nothing links a retired case to its successor, so check for one first None Sign-in as the case’s owner or as an admin. Correct or retire a published case

Phase 3 — Learn

Section titled “Phase 3 — Learn”

Find a case in the browser, work it in the terminal, hand it in. Your score is recorded as proficiency against individual components, never as one mark.

Action What it does Flags and parameters Needs first, and the full page
/ The landing page: what Fito is, how a case works, and a few featured cases None Nothing. Find a case to work on
/cases The case catalogue: full-text search, filters, ordering and paging ?q= free text · ?type= case type · ?bloom= Bloom level · ?technology= slug · ?learningObjective= component reference · ?sort=recent|title · ?page= zero-based Nothing. Find a case to work on
/cases/<id> One case’s cover: overview, learning objectives, rubric criteria, annotated artifacts, public usage stats and the launch instructions. Signed in, it adds which prerequisites you hold, which cases teach the ones you are missing, your standing in each competency the case assessed, and each of your evaluated submissions, result by result None. <id> is the case UUID you paste into every command below Nothing to read it; sign in for the personal panels. Find a case to work on
/fito-case-open Forks the case to your GitHub, clones it to ~/.fito/cases/<id>/, checks out the published version, cuts your working branch, records the enrolment, and briefs you — never the solution <case-id> required Login. gh authenticated. Open and work a case
/fito-tutor Answers case-scoped questions while you work, citing component ids. It holds no filesystem tools, so the solution, the rubric key and the quiz key are structurally out of its reach [<case-id>] · [question] An open case. Workers. Ask the tutor
/fito-evaluate Scores your local checkout against the rubric, 0 to 3 per criterion, and presents the quiz when the case carries one. A dry run: nothing is pushed and nothing is recorded <case-id> required An open case. Workers. How a case is scored
/fito-submit Pushes your working branch, opens or reuses the pull request, runs the same scoring for record, and writes the result to your profile as proficiency per component <case-id> required Login. A linked GitHub identity. Workers. Submit and read your result
/competencies Your recorded proficiency: the all-competencies table, each competence read as a level pill and a proficiency-achievement percentage, and one competence’s breakdown when you pick it ?competency= a competence id; without it the page lists them all Sign-in. Bloom levels and proficiency
/analytics Your own learning dashboards: summary tiles, proficiency progression, time to first submission, momentum, and a weekly activity window None Sign-in. Your learning analytics

Phase 4 — Curate and administer

Section titled “Phase 4 — Curate and administer”

Voting is open to every signed-in learner. The rest of this phase belongs to people who own a case, and the two dashboards to an admin.

Action What it does Flags and parameters Needs first, and the full page
Vote up or down, on a knowledge, technology or case page Records your one vote on that target. Change it or retract it at any time; the counts show inline None Sign-in. Vote on knowledge, technologies and cases
/curation The creator worklist: technologies, components and cases ranked by the downvotes each has drawn since it was last judged ?targetType=KNOWLEDGE_COMPONENT|TECHNOLOGY|CASE · ?relatedToMe= default true · ?includeSettled= default false Ownership of at least one case. Work the curation catalogue
Raise a claim, in the panel on /curation Records that a target needs improvement. One live claim per target, and you need not own the target None Ownership of at least one case. Triage indications on your case
Dispose of a claim, in the panel on /curation Settles it as RESOLVED, naming the component that answers it, or as WONT_FIX, naming why. You can adopt another creator’s resolving component instead of minting a near-duplicate None A live claim on the target. Triage indications on your case
/admin The Operations dashboard: active users, signups, events and error rate, the human-versus-bot traffic split, the top failing endpoints, and the two conversion funnels None. The window dial sets the period The users.is_admin flag, set by hand in the database. Admin dashboards
/admin/content The Content dashboard: technology demand, per-case health rows, and component difficulty as a delta from the overall average None. The window dial sets the period The users.is_admin flag, set by hand in the database. Admin dashboards

Not on this card

Section titled “Not on this card”

Four things are deliberately absent, and each has a home:

Left out Why, and where it lives
Fito’s HTTP API The card lists what a person does, not what the browser and the TUI send. Endpoints belong to the repository’s architecture documentation
Running a Fito server An operator’s job, also in the repository’s architecture documentation
The .case/ file contract A format rather than an action. See The .case/ file contract
Session tokens, the briefing surface, component search, the event stream Each sits behind an action above rather than beside it — refreshing a token, serving a case document by key, listing components for the design dialogue, recording what the dashboards count

What’s next

Section titled “What’s next”