Language: English | 한국어 | 日本語 | 简体中文

Skill Olympus

A persistent product team for your coding agent.

Plan, build, inspect, test, document, and remember across sessions — without replacing the native workers already built into your CLI.

Skill Olympus is a production-oriented harness for solo builders using Claude Code, Codex CLI, Antigravity CLI, or Grok Build. Devin CLI can also use the Claude skill surface with its own Mnemo conversation hooks. Call one specialist for a focused job, or let Zeus drive the full delivery loop.

/zeus "Build a shopping mall. React + Spring Boot + PostgreSQL"

One request becomes persisted planning artifacts, implementation, inspection, executable tests, and an evidence report. Olympus treats running out of turns as incomplete, not success.

Installation impact · Quick start · Choose a workflow · CLI support · Browse all skills

Olympus is not a prompt dump. Nineteen focused entry points stay discoverable by default; lower-level modules remain available through a source catalog, while each integrated CLI keeps its native agents, review engine, and task primitives.

---

Why Olympus

What you need	What Olympus adds
A product from one sentence	/zeus connects planning, implementation, inspection, runtime setup, tests, and an evidence-backed final report
A loop that does not bluff	/chronos runs FIND → FIX → VERIFY, records state, and reports exhaustion or blockers honestly
Proof that code matches intent	/argos compares the specification, code, APIs, scenarios, diagrams, and security boundaries
Browser tests that actually run	/minos writes Playwright scenarios, executes them, and repairs failures within a bounded loop
Memory across sessions	mnemo recalls conversational context from tags and evidence, keeps existing memories current, and supports resumable handoffs
Less prompt noise	A small active registry routes into 78 source-only modules only when the work needs them

103 public skill sources (default allowlist union: 25 = 19 user entry points + 6 runtime adapters; 21 or 22 active per integrated surface, 19 on skills-only hosts, 78 source-only internal/optional modules) · no custom agents (native subagents + skills) · 9 hooks · 4 integrated CLIs + Devin Mnemo compatibility + 2 skills-only hosts · 1 mythology

---

Before installing: what changes

The integrated installer updates your global CLI environment, so its rules also apply in your other projects. It installs workflow skills, catalogs, hooks, and MCP configuration as well as the rules below. OpenClaw and Hermes Agent remain skills-only hosts.

Runtime	Global rules updated	Saving/configuration surface
Claude Code	~/.claude/CLAUDE.md — MNEMO block	~/.claude/settings.json hooks
Codex	${CODEX_HOME:-~/.codex}/AGENTS.md — CODEX-MNEMO block	config.toml notify chain and managed skill settings
Antigravity CLI	~/.gemini/GEMINI.md — ANTIGRAVITY-MNEMO block	~/.gemini/config/hooks.json; separate CLI/MCP settings
Grok Build	~/.grok/rules/grok-mnemo.md plus Claude shared rules	~/.grok/hooks/grok-mnemo.json; Claude compatibility
Devin CLI	%APPDATA%/devin/AGENTS.md on Windows; ~/.config/devin/AGENTS.md on macOS/Linux — DEVIN-MNEMO block	Native hooks in config.json; reads Claude skills from ~/.claude/skills/

This release changes the default guidance:

• Reply in the request's language, add search tags to substantive responses, and proceed within the user's authorized scope. Read-only requests stay read-only.
• Find code through codemap/index.md first. Recall past work through MEMORY.md → relevant memory → conversation links/tags → body text → scoped source-session parsing when needed.
• Climb the ladder YAGNI → codebase reuse → standard library → native features → existing dependencies → minimal new code, and mark a deliberate shortcut with // minimal: <cap> - <upgrade trigger> so /hestia can harvest it into a simplification-debt ledger.
• Keep skill-catalog routing, documentation updates, memory limits, handoffs, and test evidence, with the appropriate native workflow and recovery limits for each CLI.

Reinstalling replaces the managed rule block, including edits inside it. Text outside the Claude/Codex/Antigravity markers stays; the Grok rule file is replaced as a whole. The integrated installer now backs up those files and Codex configuration/notification wrappers under ~/.olympus/install-backups/ before changes. Standalone adapter installers do not run this backup step.

Installation ends with automatic rule, registration, and installed-hook checks. Results are saved as verification.json; skipped execution checks are marked NOT RUN. To preview recovery, run node scripts/install-state.js restore "<manifest.json>"; add --apply to restore. Recovery restores whole files, including all backed-up Codex configuration, and stops if anything was edited after installation. See the backup scope and verification limits.

Mnemo hooks save conversation copies under your project's conversations/; memory and handoffs use MEMORY.md, memory/, and docs/handoffs/. <private>...</private> is redacted in supported Mnemo outputs, but does not erase native CLI session history. No additional model, reasoning-effort, language, or permission value is required for the new rules.

Codex user-created /fork conversations are saved separately from subagent work. The read-only trace_subagents.py finds workers by their PM's session ID and reads their messages, tool calls, results, and reports with source line numbers. It excludes inherited parent history and masks private content. See Codex-Mnemo usage.

All Mnemo adapters and handoff/recovery tools share one project-root contract. Git roots and portable .mnemo-root markers keep subdirectory sessions together; unmarked cwd values cannot create a new storage root. Inherited Git settings and storage links cannot redirect writes outside the project. Non-Git workspaces need an explicit workspace declaration or an initial root marker.

Conversation capture on Claude Code, Codex, Antigravity, Grok and Devin uses the shared record storage contract. It preserves short answers and literal text, queues failed writes in conversations/.mnemo-pending/, and retries them on the next saving event. Claude transcript UUIDs are registered after the answer is confirmed in Markdown. Node.js is required for all five adapters; Devin assistant capture also requires Python 3. Pending records are recovery data and should stay with the project.

The existing Codex installer also writes notify and sets tui.notifications=false, tui.animations=true, tui.whimsy=false in config.toml. Existing save-turn chains are retained; some desktop/IDE-only notification chains are replaced. See the exact settings and removal behavior before changing or removing a custom notification setup.

Turn Codex Astra's star effect off or on

When using an Astra model, Codex CLI can show sparkling stars behind the prompt input. This screenshot shows the effect enabled (a still image).

The Codex installation step in install.bat or install.sh enables general terminal animations, including spinners, and disables decorative star effects globally. Edit %USERPROFILE%\.codex\config.toml on Windows or ~/.codex/config.toml on macOS/Linux. If CODEX_HOME is set, edit config.toml in that directory instead.

# Update the existing root keys, before the first [table]
tui.animations = true
tui.whimsy = false

tui.animations controls general animations; tui.whimsy controls decorative effects such as Astra stars. If your file already has a [tui] table, edit animations and whimsy inside it instead of adding duplicate dotted keys.

To turn the stars back on, keep animations=true, set whimsy=true, and restart Codex. Installation and reinstallation apply animations=true and whimsy=false, including when an earlier installation set animations=false. Uninstalling Olympus leaves these settings in place. Official configuration schema · Installation settings

Customize, disable, or remove

What you want	What to do
Keep a personal preference	Put it outside the managed block; for Grok use a separate personal rule file. Use project rules for project-specific choices. Resolve conflicting old preferences explicitly.
Change Olympus defaults on future installs	Edit the canonical templates in your maintained checkout, then reinstall. Editing only the installed block lasts until the next install.
Stop automatic saving	Launch the CLI with MNEMO_DISABLE=1. This disables Mnemo saving hooks; it does not remove instructions, stop explicit agent writes, or disable native session storage.
Remove only the injected rules	Remove the relevant marked block, or Grok's managed rule file. Hooks remain; use the saving opt-out if needed. A later install restores the rules.
Remove the Mnemo adapter or Olympus	Follow the removal commands and shared-runtime caveats. Existing conversation, memory, and handoff files are retained.

For a fixed Korean preference, write “Use honorifics when replying in Korean” if you still want replies in other request languages. The installer preserves your personal text; it does not rewrite that preference for you.

Detailed settings, verification, and recovery limits · Skill collision recovery

---

Quick Start

Requires Git and Node.js LTS. The target AI CLI can be installed before or after Olympus; rerun the installer later to finish CLI-dependent registration.

Install the four integrated runtimes

# Clone
git clone https://github.com/Dannykkh/skill-olympus.git
cd skill-olympus

# Windows
.\install.bat

# macOS/Linux
chmod +x install.sh && ./install.sh

Running without arguments is the default full installation for Claude, Codex, Antigravity, and Grok. --all is an optional explicit spelling of the same selection. The installer prepares each selected CLI's files even when that CLI executable is not on PATH; only CLI-dependent commands such as MCP registration are skipped. Install the missing CLI and rerun the same installer to finish those commands.

When Devin CLI is detected, the installer also adds Devin-Mnemo: Devin reads the shared Claude skills, while native UserPromptSubmit, Stop, and SessionEnd hooks save its turns to conversations/*-devin.md. To install or inspect only this adapter, run node skills/devin-mnemo/install.js or node skills/devin-mnemo/install.js --check. Assistant capture requires Python 3 and access to Devin's local session database; a live Windows Devin turn has been verified. macOS and Linux runtime capture still needs verification.

The default MCP for Claude, Codex, and Antigravity is playwright. Context7 and Chrome DevTools MCP are optional; install either with node install-mcp.js <name> (Claude), node install-mcp-codex.js <name> (Codex), or node install-mcp-antigravity.js <name> (Antigravity), using context7 or chrome-devtools. Check project dependency versions and official documentation first; Context7 is an optional lookup tool. See the MCP setup guide. A normal reinstall preserves existing optional MCP registrations.

Try a workflow

/zeus "Build a small inventory SaaS with React, Spring Boot, and PostgreSQL"
/chronos "Fix the checkout flow until its tests pass"
/aphrodite "Redesign this dashboard around the operator's daily tasks"
/argos docs/plan/checkout
/mnemo "What did we decide about authentication?"

Skills can also activate from a matching natural-language request; slash names make the intended workflow explicit.

OpenClaw and Hermes Agent: skills-only install

These entry points install the 19 portable user-facing skills plus the 78 source-only modules. They do not install plugins, hooks, Mnemo, MCP, custom agents, or the existing four-CLI runtime adapters.

# Windows: one host at a time
.\install-openclaw.bat
.\install-hermes.bat

# Or select both through the TermSnap-oriented installer
.\install.bat --llm openclaw,hermes

# macOS/Linux
bash ./install-openclaw.sh
bash ./install-hermes.sh

Use --uninstall with a host-specific installer to remove only that host's Olympus-managed skills.

Updating an existing installation

A normal update does not require an uninstall first. Running the installer again reconciles only Olympus-managed names with the current policy and leaves unrelated third-party skill names in place.

Codex sync also checks direct skill folders in ${CODEX_HOME:-~/.codex}/skills and ~/.agents/skills. When the frontmatter name and the complete file trees match, it keeps the Codex copy enabled and disables the shared copy through config.toml; both copies stay on disk. Different contents are reported for review, and explicit user enable/disable settings are preserved. On later syncs, installer-owned disables are removed when the copies diverge or one disappears; uninstall removes only the unedited installer-owned config block. Changed configs are backed up under the Codex home's .olympus/backups/. Linked resources or unsupported config forms produce a warning and are left for manual review. This check excludes nested skill folders and plugin bundles. Restart Codex after configuration changes. Many distinct skills can still trigger the description-budget warning.

git pull
.\install.bat

Use ./install.sh on macOS/Linux. Uninstall and reinstall only when the installation is broken or when you deliberately want to rebuild Olympus hooks and MCP registrations from scratch.

.\install.bat --uninstall
.\install.bat

What does source-only mean?

Source-only does not mean that an old skill version is being retained. It means that the current Olympus SKILL.md and supporting files remain available without being registered in the CLI's automatic discovery directory.

• Current sources are copied under each CLI's .olympus/source-skills/ and recorded in SKILLS-CATALOG.md.
• An active Olympus harness or the LLM can read that catalog source when a task needs it.
• Use --include-source-only-skills to put every compatible source-only skill back into slash menus and automatic matching.
• That option activates current Olympus sources; it does not restore an older modified copy from _olympus-preserved.

.\install.bat --include-source-only-skills

A missing CLI does not suppress asset preparation. Its skill catalog, source library, hooks, and configuration files are prepared; only commands that require the executable are reported as skipped.

When upgrading an existing installation, unrelated third-party skill names are preserved. Modified same-name collisions are moved to _olympus-preserved instead of being discarded. See the skill registry migration guide for the lightweight default, full opt-in, collision recovery, and uninstall/reinstall procedure. Recovery is manual: copy the preserved skill back only after giving both its directory and frontmatter name a unique name. Otherwise the next sync will preserve it again. --uninstall never restores backups.

---

How it works

Zeus is the harness layer: one request is kept alive, decomposed, implemented, inspected, prepared for runtime use, tested, and reported without handing an unverified next step back to the user. It bootstraps Chronos persistence, drives Zephermine planning, routes implementation through the current CLI's native workers, and requires Argos, Docker, Minos, and a final evidence report before SUCCESS is allowed.

Zephermine and Daedalus first use existing code, documents and domain research to present evidence, a recommended approach and its tradeoffs. They reuse earlier answers across phases and resumes, asking only for unresolved decisions or internal facts that the available material cannot settle. Work that does not depend on those answers can continue within the agreed scope.

Chronos is the loop layer under that harness. It prefers native /goal, uses runtime-specific continuation when needed, and returns to READ → FIND → FIX → VERIFY → LOG. Complete requires proved requirements and passing verification; Blocked and Exhausted remain incomplete. Parked issues carry an Owner Decision Brief, and retries retain their original limits across phases and resumes.

---

The Pantheon of Olympus

Beyond the wine-dark sea, where clouds part above the world, Mount Olympus rises. On its windswept summit dwell the Twelve, each crowned with their own dominion, each known by an ancient and many-named song. Speak the name of one, and that one alone shall descend the holy mountain. Speak the name of cloud-gathering Zeus, and the whole pantheon shall come down with him in golden procession.

This is no mere tool-chest. It is a small mythology of work, a council of immortals each shaped to a single craft. They work as the old singers tell us they have always worked — gentle Zephermine, breath of the west wind, whispers a blueprint into the ear of earth-shaking Poseidon; Poseidon stirs the deep and his fleet sails forth in waves; hundred-eyed Argos walks the shore at dusk to count every nail and every beam; stern Minos sits upon his marble throne to weigh each soul at the gate; and last of all, fair-tressed Clio takes up her stylus to carve the whole tale upon a tablet of bronze, that mortals yet unborn may read of it.

Below stand the immortals. Call upon one — or call upon all.

The Twelve Who Sit Upon the Mountain

Skill	Name	Epithet	Domain
/zephermine	Zephermine (젭마인)	Breath of the West Wind, Bringer of Spring	The Architect — research-led planning, implementation specs and domain review
/zeus	Zeus (제우스)	Cloud-Gatherer, Hurler of Thunderbolts, Father of Gods and Men	The Sovereign — Zero-interaction full pipeline; at his nod the council convenes
/agent-team / /poseidon	Poseidon (포세이돈)	Earth-Shaker, Lord of the Wine-Dark Sea, Trident-Bearer	The Sea Lord — Reads dependency graphs as a sailor reads tides; sends the fleet in waves
/workpm	Daedalus (다이달로스)	The Master Builder, Maker of the Labyrinth, Father of Wings	The Hands-On Builder — Where there is no plan, he becomes the plan
/argos	Argos (아르고스)	Argos Panoptes, the All-Seeing, of the Hundred Eyes	The Watchman — Of his hundred eyes, none ever sleep at the same hour
/minos	Minos (미노스)	Judge of the Dead, Keeper of the Golden Scales	The Judge — At his marble throne, every soul and every test is weighed
/clio	Clio (클리오)	Kleio, Proclaimer, Muse of History, Daughter of Memory	The Chronicler — Her stylus sets down what mortals have done, that none may forget
/chronos	Chronos (크로노스)	Father of Time, the Unwearying, He Who Devours the Hours	The Tireless — Time itself is his servant; he turns the wheel until the deed is done
/hermes	Hermes (헤르메스)	Wing-Footed Messenger, Guide of Souls, Patron of Merchants	The Wayfinder — Reads the trade-winds and the marketplaces of distant lands
/athena	Athena (아테나)	Gray-Eyed Daughter of Zeus, Defender of Cities, Born from the Skull

---

Songs from the Mountain

Hear now the voices of the Twelve, as the old singers heard them.

🜲 Zeus, Cloud-Gatherer Upon the topmost peak he sits, and his nod is the law of mountains. When his voice rolls out across Olympus, the council rises as one and descends — designer, builder, watchman, judge, and chronicler — all at his single word. "Speak my name once, mortal, and the whole council shall walk beside you to the end."

🜂 Zephermine, Bringer of the West Wind She is the soft breath that wakes the seed beneath the soil. Six and twenty are her questions, and the breath of each one is gentle — yet none may pass her by, for the spec is sacred and half-told tales bear no fruit. "I ask, and ask, and ask again — until what was unspoken becomes a thing of stone."

🜄 Poseidon, Earth-Shaker He stands knee-deep in the wine-dark sea, his trident raised, and the waters listen. The fleet of teammates lies in the harbor, and at his bidding the wave gathers them all and bears them out together, each prow pointed where the dependency graph commands. "The sea does not yield to the swimmer. The swimmer who knows the tide — she yields to him."

🜔 Daedalus, Master Builder Before him there was no labyrinth in all of Crete. He took stone from the mountain and shaped it with his own hands, and the work was good. Where the blueprint is missing, where the architect has not spoken, send for him — he will research, he will draft, and if no other hand will rise, his alone shall raise the walls. "Give me the stone. The plan I shall make as I go."

👁 Argos Panoptes, the Hundred-Eyed He paces the half-built city by night, and at no hour are all his eyes closed at once. The plank a mortal builder forgot to nail — he has already seen it. The line of code that fails to match the spec — he has already named it. "While fifty of my eyes rest, fifty more keep watch. Nothing passes Argos in the dark."

⚖ Minos, Judge of the Dead He sits upon a throne of cold marble at the gate where the souls of the dead must come. He raises his golden scales, and the work is weighed against itself. His verdict is two-fold and no other: it shall pass, or it shall return to the fire. "Stand before the scales, child of mortals. We shall see if your tests are honest."

📜 Clio, Muse of the Long Memory She comes last of all the gods, after the labor is laid down. Her stylus is bronze and her tablet is the years to come. What the heroes have done, she sets down — diagram, decree, manual, and song — that the children of the children of those mortals may know the deeds were real. "The work has ended. Now begins the telling, and the telling endures."

⏳ Chronos, the Unwearying He is older than memory, older than the gods themselves. He turns the great wheel of the hours and does not tire when mortals sleep. The bug shall die or the dawn shall come — and Chronos shall outlast them both. "Mortals close their eyes. I do not. The work shall be finished, by sunrise or by the next."

🪶 Hermes, Wing-Footed He moves between the worlds — the high palace and the low marketplace, both are his road. He reads the trade-winds of distant lands and the price of grain in city-gates yet unseen. Before a single coin is risked, before a single line of code is written, he speaks first. "Every market is a road, traveler. Every road has its toll. Bring silver, or bring nothing."

🦉 Athena, Gray-Eyed She was born full-grown from the skull of her father, helmeted, spear in hand. Her wisdom does not flatter; her counsel is the cold edge of the bronze. She will ask the question the mortal fears most — should this thing be made at all? "Wisdom, child, is to know which work must never be begun. I shall ask. You shall answer."

🌹 Aphrodite, Foam-Born She rose from the white foam of the sea, and the world has not been plain since. Nine palettes lie at her hand, seven and forty font pairings, four and eighty styles. What leaves her workshop is not merely useful — it is loved, and that is the difference. "Beauty is not the ornament of the work. Beauty is what makes the work survive its maker."

📚 Mnemo, Mother of the Muses Long before the nine sisters sang, Mnemosyne kept the long memory of the world. The conversation a mortal had three moons ago is the answer she carries to him today. Three layers she keeps — the index of names, the meaning of things, the tale itself — and her remembering crosses every session, every CLI, every dawn. "Forget nothing, child. The word you spoke long ago is the gift you needed now."

---

Recent changes

v7.5.1: The humanizer skill now ships the MIT license notices of the two projects it adapts, blader/humanizer and im-not-ai, as LICENSE.upstream-humanizer and LICENSE.upstream-im-not-ai. The files are unchanged from upstream and are installed with the skill. Skill rules are unchanged.

v7.5.0: The humanizer's Korean module now follows im-not-ai b37e020. It lists 84 patterns, including the strongest measured signal, the "A가 아니라 B" (not A but B) construction. Hedges and obligations keep their mood: a repeated form is varied or moved rather than turned into an assertion or a suggestion, and medical, legal, policy and negotiation text keeps its hedges. Expressions that people use more often than AI are changed only where they cluster. Self-checks compare counts of hedges, obligation markers and connective commas, and confirm that content anchors (facts, figures and names that must survive) remain. Examples that contradicted these rules were rewritten. Upstream scripts and multi-agent routing were not ported, and rewrite quality has not been measured against the upstream corpus.

v7.4.3: Planning leads with evidence, a recommendation and tradeoffs, reusing answers across phases and resumes. Argos and Minos use the shared root-cause debugging procedure within existing repair limits; Zeus preserves their final grades, exploratory QA failures and spent budgets, and checks legacy-state recovery before resuming. Chronos distinguishes Complete, Blocked and Exhausted. Reviews and worker handoffs retain their original scope and baseline, while autoresearch rejects unsupported changes and contaminated evaluation results. See the workflow improvements and planning and resume validation for checks and limits. Shorter interviews and full product-pipeline execution across all CLIs have not been demonstrated.

v7.4.2: Context7 is optional. The integrated installers register only Playwright by default for Claude, Codex and Antigravity; Grok shares the Claude surface. Existing Context7 registrations, explicit installation and the standalone MCP scripts' --all option remain available. Zephermine's section template now checks project dependency versions, existing code and the matching official documentation first, without requiring Context7. Setup guides and resource recommendations follow the same policy. Validation: 53 installer, policy, portable-frontmatter and module-routing checks passed. See the MCP setup guide.

v7.4.1: Poseidon and Daedalus keep the main agent responsible for task allocation, dependencies, verification and final integration, while workers implement and run related tests. Tasks follow coherent responsibilities instead of fixed worker or file counts. Related fixes and retests stay with the same worker; dependent work uses one worker or sequential assignments. Direct implementation by the main agent remains a fallback for unavailable or failed delegation. Zeus follows the same contract, including loading the common PM instructions before any optional MCP path. Wave state updates belong to the lead, and review and tripwire gates remain required. Validation covered 73 regression checks, five skill-format checks and independent allocation scenarios; product quality, speed and cost gains have not been measured. See the workflow guide.

v7.4.0: Poseidon and Daedalus now classify failures before retrying. Clear implementation defects get direct fixes; evidence of missing context, poor task decomposition or tool ordering can trigger a bounded comparison within the existing retry budget. The shared policy preserves the selected execution engine and records task recovery separately from evidence that the execution strategy improved. A successful retry with different inputs remains recovered + unverified. Mnemo retains the evidence and applicability conditions at handoff; this adds skill instructions, not a new runtime engine.

Minos chooses whether to fix implementation or tests against the current requirements and specification. Zephermine preserves unvalidated demand assumptions and carries reproducible AI evaluation criteria into section acceptance checks; Argos checks that evidence. Daedalus uses the existing contract and tests for small changes that leave the flow unchanged. Targeted regression checks passed 56/56, and two execution-adjustment scenarios ran three times, including the installed Codex catalog path. General quality, speed and cost gains have not been established. See the execution adjustment validation and Builder workflow comparison.

v7.3.0: Zephermine plans now set tripwires: conditions, fixed while the decision is made, for when to look at it again. Under ## 전략 선택, a plan names objective metrics with where each is measured and when it is judged (during the build or after launch), then the early signal, the condition to keep going, the threshold to revise and the condition to review stopping. Every number is marked either as verified, with its source, or as an assumption, with how and when it will be checked; a threshold picked from a measured baseline is still an assumption. The riskiest assumption becomes a section with no dependencies, so it is judged in the first Wave. The build harnesses judge at their own boundaries: Poseidon (/agent-team) after each Wave's code review and before the next Wave starts, Daedalus (workpm) right after the risky-assumption task and before its process check, and Chronos every cycle, parking the remaining issues as product decisions once a revise or stop line is reached. Zeus does not stop; it records the hit in its decision ledger and puts any stop review at the top of its report. The leader assigns the stage, the named owner decides, and a stage already reached is never erased by moving the line afterwards. Safety and legal metrics are switched off at once instead of waiting for review. Athena attaches the same format to GO and CONDITIONAL GO verdicts. In blind audits, workers who saw only the guide caught every defect planted in sample execution logs, including a baseline lowered after the result was in. 272 Node tests passed.

v7.2.1: Aphrodite's font-loading guidance no longer trusts document.fonts.check(). The call returns true for a family name that no @font-face declares, even while the text falls back, which is how the Pretendard mistake fixed in v7.2.0 passed review; computed font-family only echoes the declaration. The DESIGN.md guide and the ui-ux-auditor typography check now say to copy the family name from the loaded CSS ('Pretendard Variable' for the jsDelivr variable build, Pretendard for the static build, 'Pretendard GOV' for GOV) and to judge loading with document.fonts.load() plus a render-width comparison; the guide includes a snippet you can run as is. In a blind run, a worker who saw only the revised text caught a planted defect and exposed a false positive in the first snippet: a heading stack with a Latin font first reported the font as applied under a wrong name. The snippet now measures an unspaced sentence at the real weight against the stack without the checked font. Run verbatim, it loads 5 faces for the right name and 0 for the wrong one. 265 Node tests passed.

v7.2.0: /video-maker gains brief types and a Capture stage. narrated stays the default, motion-short makes an unnarrated clip of about ten seconds with Voice and Captions skipped, and app-promo records real screens before the script: launch films are built from captured pages, and app demos from a deterministic replay with a virtual camera added afterwards. If capture fails, the run stops instead of drawing a fake UI. Korean narration gets safe defaults: Kokoro (no Korean voice) is not used, Typecast returns word and character timestamps, Gemini TTS is a new provider, and a known TTS script is force-aligned before any free transcription. Render QA now measures frozen frames and loudness and records a hash for every generated or captured asset. The HeyGen HyperFrames bundle reference follows v0.8.168, which moved the storyboard and script formats and needs HYPERFRAMES_SKIP_SKILLS=1 on CLI runs. Aphrodite's frontend-design module adds a corporate-trust style recipe, a conditional candidate for regulated, B2B and procurement audiences that have real figures or certifications. Trust-first screens may use a system font stack or a 500–600 weight Pretendard display when DESIGN.md records the reason, and the Trust & Authority style trades pulsing metrics for near-zero motion. Recipe font stacks now name Pretendard Variable (36 stacks in 10 recipes), the only family the jsDelivr variable CSS declares; before, Korean text silently fell back to the system Gothic (the same sentence measured 446.8 px instead of 389.3 px), and a new contract test catches the mistake. 265 Node tests passed.

v7.1.1: Mnemo Doctor and recall now read memory through one shared rule for metadata lines and entry names, fixing false alarms and misses reported from a 467-entry project. Bold headers such as - **Date**: no longer split an entry into its subsections, and legacy ### NNN-slug heading links resolve in the Doctor exactly as recall opens them. Replacement reasons written a few lines below the status line are found. depends-on links to entries that do not exist are counted, and a CURRENT entry that still depends on an entry it fully replaced is named. Entry files saved with a UTF-8 BOM, which both tools skipped, are read again. Size checks ignore derived dot-files and backup folders, and --fix/--promote-structure back up the original bytes and keep CRLF line endings. Korean field names are reported, not accepted, because recall and the other CLIs read only the standard names. All five CLIs receive the fix through the shared Mnemo scripts. 260 Python checks passed; on the reporting project, unresolved lifecycle targets fell from 13 to 0 and reasonless replacements from 16 to 0.

v7.1.0: Codex-Mnemo adds read-only PM-to-worker history lookup. It finds direct and nested subagents by the PM's exact session ID and returns their messages, tool calls, results and reports with source line numbers. User-created /fork conversations are now saved; inherited parent turns remain excluded from recovery. This tracing feature is Codex-only. The shared conversation-saving fixes from v7.0.5 remain available across Claude Code, Codex, Grok, Antigravity and Devin. Storage, recovery, tracing, packaging and policy checks passed (74); installed-hook execution and real worker-history lookup were also verified.

v7.0.5: Mnemo fixes conversation omissions across five CLIs. Codex keeps every actual user input, including steering messages, and Claude/Grok retain short answers such as OK. Claude preserves identical new prompts and records UUIDs only after a successful write; Antigravity stores every unrecorded user input before the latest answer. A shared writer retains failed content, rolls back partial appends and retries on the next event. Devin also keeps delayed-answer queries within the previous prompt's database row range. Windows concurrent deletion checks retain external-link protection, and installed adapter packages include current reinstall scripts. Windows tests (250), installed-adapter tests (24) and real Claude/Grok/agy/Devin OK capture passed. Bash stdin handling, opt-out verification pipes and release-file staging instructions are also fixed.

v7.0.4: On Windows, the Claude Code Stop hook no longer wipes the Codex sections of the shared conversation index. conversations/.mnemo-index.json holds a claude section written by the Claude hooks and codex/codex_aborted sections written by the Codex reconcile tool, but the PowerShell Stop hook rewrote the file with only version and claude after every answer. It now updates claude and keeps every other section as it is. If it can't read the index, it logs index-read to .claude/mnemo-errors.log and leaves the file alone instead of replacing it with an empty one; the answer is still saved. The Bash hook and the reconcile tools already kept the other sections. No conversation records were lost: Codex sections dropped earlier are rebuilt from the conversation files the next time the Codex reconcile tool runs.

v7.0.3: Codex Mnemo no longer saves subagent turns as your conversation. Codex runs the notify hook when a subagent finishes a turn too, and nothing in that input marks a subagent. save-turn therefore stored subagent reports as turns. When input-messages was empty it took the user text from the newest session in the folder, which was often a subagent session whose only user message is the full AGENTS.md instructions. save-turn now opens the session file named by the notify thread-id and skips the turn when its session_meta marks a subagent, using the same rule as the reconcile tool. For those turns it also skips observations and the Chronos continue loop, so a subagent finishing can't start a resume while the parent turn is still running. The changed-file checks still run. Injected messages (AGENTS.md, <environment_context> and similar) are no longer saved as user text, and the Windows fallback reads the turn's own session. Turns with no session file, such as codex exec runs that keep no session, are saved as before. Records saved earlier stay until reconcile removes them. To see what a full run would change, use reconcile_codex_conversations.py --all --staging-dir <folder>; --dry-run skips the merge and always reports zero removals.

v7.0.2: The Claude Code Mnemo hooks no longer drop the final answer or record machine-injected turns. The Stop hook now saves the last_assistant_message that Claude Code passes in, so a hook that runs before the transcript has flushed the final answer no longer stores an earlier progress note in its place; older CLIs without that field still read the transcript. The UserPromptSubmit hook skips turns whose source is system and <task-notification> task notifications; prompts you type and prompts re-entered by /loop or scheduled tasks are still saved. Other CLIs are unchanged: Codex and Grok already take the last answer from their hook input, and Antigravity's Stop input carries no answer text, so it keeps reading the transcript.

v7.0.1: The release-notes skill no longer runs git add -A before the release commit, so unrelated edits and untracked files (build output, archives, local settings) stay out of it. It stages CHANGELOG.md and the version files it updated and commits them with a pathspec, which also keeps anything already staged for other paths out of the commit. Annotated tags now use --cleanup=verbatim, so the CHANGELOG's ### section headings stay in the tag message instead of being stripped as comments.

v7.0.0: Custom agents no longer ship. The 33 standalone reference agents and the two skill-owned compatibility prompts (chronos-worker, gotcha-analyzer) are removed together with the agent install pipeline: native subagents handle delegation and skills own their procedures. Mermaid state-diagram syntax, which only an agent carried, moved into the mermaid-diagrams skill. Breaking: --include-source-only-agents and the other agent flags are accepted but ignored. Installs move agent files named like any agent Olympus ever shipped (for example ~/.claude/agents/architect.md) to a timestamped backup folder and delete the generated AGENTS-CATALOG.md and agent sync manifests; Codex and Antigravity copies you edited are preserved instead of deleted.

v6.21.1: Removed the unused ai-ml agent source. Since custom agents became source-only it was never installed or read by any skill, and its Gemini example still taught the retired google.generativeai SDK. For LLM API work, follow the project's SDK and the provider's official docs: the built-in claude-api skill in Claude Code, openai-docs in Codex, and context7 for other libraries. Agent sources are now 35 (33 top-level + 2 skill-owned); none are registered by default.

v6.21.0: Aphrodite now measures motion under real browser input when creating, adapting, or replicating a website. Its motion engineering guide covers engine selection, frame timing, physical response, and reference measurement. A Playwright helper records input and state on the same timeline and checks each scene's response, intermediate states, and settling. Missing criteria remain UNVERIFIED; numeric checks accompany visual, mobile, and reduced-motion review. See the guide and motion-web assessment.

v6.20.0: Carry what worked into the next project. /recipe harvests something you built well — a UI piece, a backend flow, an MCP tool, an infra script — as a recipe: recipe.md, the explanation an LLM reads to rebuild it (what people call llm.md: when to use it, the contract, the decisions and the traps), plus a sample that runs on its own. Recipes live in a private library outside this repository and your projects (CODE_RECIPES_DIR, default ~/code-recipes). Harvesting strips the source project (brand values, real APIs, secrets, personal data), asks only whether the code may be reused, runs the sample, and can have a worker with no context rebuild it to prove the recipe is enough. Aphrodite, frontend-design, Zephermine sections and Daedalus look recipes up and reference them as recipe: <id>@<version> instead of copying them.

v6.19.0: Programs are now designed to be driven by an LLM as well as by people. Zephermine writes a separate mcp-spec.md (Step 17A) for web, server and local programs alike: what an agent will be asked to do (starting from what it actually knows — an email, not an id), which functions open as MCP tools (closed by default), and for each tool its risk annotations, call limits, audit trail and error text the model can act on. Tools wrap the REST endpoints by reference instead of copying their schemas; local programs without REST wrap the same internal commands the UI calls, never the database directly. api-spec.md stays the HTTP contract and gains a MCP Tool column. Daedalus applies the same MCP conventions without a spec, and Argos audits implemented tools against the spec (Phase 3A).

v6.17.0: Design and build now share named promises. Zephermine gives every section's acceptance criterion a stable ID (AC-NN-k) with an observable behaviour, a trace and a verification, collects them into checklist.md, and checks that every problem has an AC, every AC can be verified, and no two AC contradict. Poseidon, Daedalus and Chronos record progress in one checklist-status.md ledger (proved needs executed evidence; done means every row is proved), Argos re-runs that evidence (Phase 4A) and Clio counts unmet AC as a NO-GO blocker. api-spec.md now starts from what each screen shows and does, every list endpoint is paginated, errors use one coded format, and list filter/sort columns are backfilled into the index plan. Poseidon's ownership check compares against a start-of-run baseline instead of HEAD~N, and autoresearch judges the final skill on holdout inputs it never optimised against. Six custom agents that duplicated same-name skills were removed (42 → 36 agent sources).

v6.14.1: Hooks and the health check no longer mistake a name for a working Python. On Windows, python and python3 can be Store aliases that exist on PATH but fail to run; macOS ships only python3. The anchor-rebuild and API-validation hooks now use the first of python, py, python3 that actually runs, so they no longer skip the rebuild or report false syntax errors, and project roots with spaces work. install.js --check tells you how to install Python or turn the aliases off, and agents report the handoff tools as unavailable only when all three fail.

v6.14.0: In projects with a TermSnap component map (codemap/component-map.json), create_handoff.py adds a Component map: line that reads TermSnap's codemap/components/owners.json and reports this session's files that have no owning component, files that need the map regenerated, and map errors. validate_handoff.py warns when those findings carry neither → 배정함: (assigned) nor → 보류: (deferred). Projects without a map get no line. The skill only reads the contract; it never edits the map or re-implements TermSnap's source rules. This release also stops record paths under dot folders (.github/…) from losing their leading dot, which had dropped them from Files Modified and anchor lookups.

v6.13.0: Mnemo tag lines now carry learned:NNN and gotcha:NNN alongside arch:NNN, and validate_handoff.py warns when a memory entry the current session touched never reached its tag line, or was written as arch-057 instead of the colon form. The session comes from the handoff's session <uuid> evidence, so other sessions on the same day are not blamed.

v6.12.0: Mnemo now bundles its own session-learning and project-skill improvement procedures for standalone installation across Claude Code, Codex, Antigravity, and Grok. Handoffs use explicitly supplied request evidence instead of guessing the session origin.

See CHANGELOG.md and GitHub Releases for the complete history.

---

Choose a workflow

Start with the outcome you want. Every workflow works independently; Zeus composes the delivery path without silently adding the optional business, CEO, or documentation stages.

I want to…	Start with	Result
Build a product from one sentence	/zeus	Planned, implemented, inspected, tested project plus an evidence report
Decide whether an idea is worth building	/hermes → /athena	Business case followed by a Go/No-Go and scope verdict
Turn an unclear feature into an implementation-ready plan	/zephermine	Spec, plan, schema, API contract, role-laned flows, RBAC matrix, and QA scenarios
Implement an existing plan in dependency-safe waves	/agent-team or /poseidon	Native-worker implementation plus an integration gate
Start coding without a prior spec	/workpm or /daedalus	Researched proposal, implementation, and verification log
Design or redesign a real interface	/aphrodite	Rendered wireframes and decision checks before visual directions, then DESIGN.md and implementation
Verify code against the plan	/argos	Evidence-linked construction inspection report
Make browser and API tests pass	/minos	Playwright tests and bounded repair cycles
Keep fixing until a measurable condition is met	/chronos	Resumable audit log, verified fixes, or an honest blocker brief
Close the project and write the docs	/clio	GO/NO-GO, diagrams, PRD, technical guide, and user manual
Reuse something you built well in a new project	/recipe	A recipe (recipe.md + runnable sample) in your private library, rebuilt by reference

---

How the Gods Work — Practical Guide

The myth above is the flavor. Here is the plain version: what each god is for (which work it handles), how you call it, and what files you get back. Every god works standalone; chained in order, they form the pipeline.

Strategy & validation — before a line of code

/hermes — Business case (Wayfinder)

• When: validating whether an idea is worth building — demand, market, money.
• Use: /hermes (aliases: 헤르메스, 사업성)
• Process: demand validation → BMC → TAM/SAM/SOM → revenue & pricing → GTM → North Star → cohort. Generates 2-3 scored business-model candidates before committing to one.
• Output: docs/hermes/{project}.md (analysis + Mermaid) + a domain-term seed Zephermine reuses.
• Next: /athena to pressure-test, or /zephermine to design.

/athena — CEO challenge (Strategist)

• When: deciding should this be built at all? before committing resources.
• Use: /athena (aliases: 아테나, ceo) — auto-reads docs/hermes/*.md if present.
• Process: demand confidence → moat → scope mode → ROI → verdict.
• Output: docs/athena/{project}.md — GO / CONDITIONAL GO / NO-GO + scope recommendation (Reduce / Expand / Pivot / Kill).
• Next: /zephermine if GO.

Design — turn intent into a buildable spec

/zephermine — Deep design (Architect)

• When: a feature/product needs a thorough spec before implementation.
• Use: /zephermine [spec-path] (aliases: 젭마인, 제퍼마인)
• Process: 26-step pipeline — research → recommendations and focused clarification → spec synthesis (incl. the Role Inventory that fixes every downstream role ID) → 6-expert team review → strategy-candidate scoring (ToT) → plan → DB schema / API spec / flow diagrams → section split → operation & QA scenarios → role-name consistency check.
• Output: docs/plan/<feature>/ → spec.md, plan.md, db-schema.md, api-spec.md, mcp-spec.md, flow-diagrams/, sections/, operation-scenarios.md, qa-scenarios.md, checklist.md.
• Role interview: step 6 builds on research and existing answers to identify who signs in, their work and prohibited actions, then recommends shared or separate screens. Only unresolved internal facts or scope choices become critical questions; agreed decisions are not asked again. Role defaults are marked [inferred] and follow the interview protocol.
• Roles: the Role Inventory in spec.md is the single source of role IDs. api-spec.md lists allowed roles per endpoint, flow-diagrams/ splits role lanes with permission-denial paths, and operation-scenarios.md carries the RBAC matrix (role x resource x CRUD) plus denial behaviour. Single-role or unauthenticated projects record NOT APPLICABLE: single role and skip all of it.
• Acceptance checklist: every section's Acceptance Criteria carry a stable ID (AC-NN-k), an observable behaviour, a trace (problem, screen, endpoint, role) and a verification (test, QA case, command). Step 22A collects them into checklist.md — the contract between design and build — and the final check verifies every problem has an AC and every AC can be verified. Poseidon, Daedalus and Chronos record progress in the shared checklist-status.md ledger (proved/weak/missing/contradicted, evidence required for proved); Argos re-checks the evidence and Clio counts unmet AC as a NO-GO blocker.
• API contract: starts from a screen data-requirements table (what each screen shows, does, filters and sorts) and derives endpoints from it plus the DB CRUD, so screens that need joined or aggregated data do not force the backend to be rebuilt mid-implementation. Conventions are fixed up front: every list endpoint is paginated (offset / + by default, cursor for feeds; size cap, sort allow-list), every error uses , and list filter/sort columns are backfilled into the index table. Section files carry these rules to implementers, and the final check verifies screen↔API coverage.

/aphrodite — Design system (Beauty)

• When: a UI project needs an intentional experience, benchmark interpretation, and consistent implementation before the frontend build.
• Use: /aphrodite (aliases: 아프로디테)
• Process: source-mode routing and exact Codex Product Design availability check (recommend once only when confirmed; UNKNOWN stays local) → benchmark evidence and Product Facts/Content Integrity/Asset Provenance → Experience Contract draft → rendered grayscale wireframes on desktop and mobile → check hierarchy, structure, flow, consistency, and clarity → explore 3 visual directions → refine the contract and DESIGN.md → implementation or same-contract adapter comparison → rendered UX/accessibility/performance gates. A visual candidate that changes the primary action or information order returns to the wireframe check.
• Output: rendered wireframes and a layout blueprint with decision evidence, Experience Contract, DESIGN.md (visual tokens), benchmark evidence, and the frontend build. Text and actions stay readable in the wireframe; only media uses placeholders. Separate images for every UI element are unnecessary.
• Example: mobile coffee flow, desktop home, and decision record.
• Per-role screens: when a Zephermine plan is present, Aphrodite reads its Role Inventory and RBAC matrix instead of inventing role names. Roles marked "shared screen" get a role-variant grid (element x role, valued visible / hidden / disabled / read-only); roles marked "separate screen" get their own layout blueprint. Hidden and disabled are kept distinct — hidden conceals that the permission exists, disabled admits it and blocks. The contract validator requires the variant grid whenever roles are declared.
• Web motion: For motion-led scenes, prototype the core interaction, measure references under real input, and verify scene-specific response, intermediate states, and settling. CSS/DOM, existing Motion/GSAP, and Canvas/WebGL are selected by need; numeric checks accompany visual critique and reduced-motion checks. See the motion engineering reference.

Build — write the code

/agent-team (/poseidon) — Parallel build (Sea Lord)

• When: a spec with sections/ exists and you want parallel implementation.
• Use: /agent-team <planning_dir> (aliases: 포세이돈)
• Process: dependency graph → wave grouping → teammates build in waves → mandatory post-merge integration gate (build + full test suite + one E2E). Progress against the design's checklist.md goes into the checklist-status.md ledger (every AC proved with executed evidence), and file ownership is checked against a start-of-run baseline.
• Output: implemented code + verification report + checklist-status.md; the integration gate is the sole completion authority (code-existence checks are pre-checks only).
• Next: /argos, /minos.

/workpm (/daedalus) — Build without a spec (Master Builder)

• When: no design exists and you want a PM that goes straight to implementation.
• Use: /workpm (aliases: 다이달로스)
• Process: research → 3 proposals scored on fit/risk/effort → the approved proposal's completion criteria fixed into checklist.md → flow diagram → implement → verify (tests/lint, bounded retries); progress kept in checklist-status.md, activity log externalized for resume. API work follows zephermine's list and error conventions (paginated lists, size cap, sort allow-list, one coded error format) even without a spec, and the review checks them along with N+1 queries and filter/sort indexes. MCP work follows the mcp-spec-guide.md conventions the same way.
• Output: working code + decision/activity log.
• Next: /argos, /minos.

Both build harnesses can adjust task context, decomposition, or tool order when execution evidence points to a workflow problem. They use the shared execution adjustment contract within the existing retry budget. Task recovery and evidence that a strategy improved are recorded separately; normal implementation defects still use direct fixes. Mnemo later retains the evidence and applicability conditions. Reading this contract does not select the MCP runtime.

Verify — prove it works

/argos — Construction inspection (Watchman)

• When: after build — confirm the code matches the design artifacts.
• Use: /argos [planning_dir] (aliases: 아르고스, 감리)
• Process: static analysis → runtime checks → API-spec match → MCP-spec match (3A: unapproved tools, bypassed targets, missing limits) → QA-scenario checklist → acceptance-ledger re-check (4A: re-runs the evidence, separates contract defects from unbuilt work) → flow-diagram-vs-code → security (Phase 0–7).
• Output: <planning_dir>/verify-report.md.
• Next: fix findings, then /minos.

/minos — E2E test loop (Judge)

• When: you need real browser/E2E tests that actually pass, not "looks done".
• Use: /minos (aliases: 미노스)
• Process: scenarios (from qa-scenarios.md or auto-generated) → Playwright code → run → fix-until-pass → browser-exploration QA.
• Output: tests/e2e/{feature}.spec.ts + tests/api/{feature}-api.spec.ts + pass results.
• Next: /clio.

Deliver — write it down

/clio — Closer + docs (Chronicler)

• When: the work is done and you need a GO/NO-GO call plus deliverable docs.
• Use: /clio (aliases: 클리오; legacy /closer)
• Process: pipeline GO/NO-GO (reads argos/minos and the acceptance ledger + runs build/test; unmet AC block GO) → source-based flow extraction → PRD / technical / manual generation → doc fact-check gate.
• Output: docs/clio/latest/ → CHECKLIST.md, flow-diagrams/, PRD.md, TECHNICAL.md, USER-MANUAL.md, FINAL-REPORT.md.
• Next: ship.

Reuse — carry what worked forward

/recipe — Recipe library

• When: you built something well (a popup, an upload flow, an MCP tool wrapper, a CI script) and want the next project to start from it — or you want to check whether you already have one.
• Use: /recipe harvest <file or folder>, /recipe find <words>, /recipe use <id>, /recipe list, /recipe where (or say "make this a recipe", 레시피로 뽑아줘, llm.md로 추출).
• Process: pick proven work and confirm the reuse scope → strip the source project → write recipe.md (decisions and traps drawn from Mnemo memory) → run the sample and record the result → optional rebuild by a context-free worker (Claude, Codex, Antigravity, Grok or Devin) → recipe-lib.js check and index.
• Output: ~/code-recipes/<ui|backend|mcp|infra>/<id>/ with recipe.md and sample/, plus an index.md across recipes. Using a recipe rebuilds it in the project's own stack and conventions with a recipe: <id>@<version> marker.
• Next: when a project improves on a recipe, harvest it again to bump the version.

Always running — orchestration, loop, memory

/zeus — One command, the whole council (Sovereign)

• When: you want a whole SaaS from one sentence, zero questions.
• Use: /zeus "Build X. React + Spring Boot" (aliases: 제우스)
• Process: seven phases: description parsing → zephermine → agent-team/workpm → argos → source-only docker-deploy → minos → final evidence report. Hermes, Athena, and Clio are not implicit Zeus phases. Decisions are automated and logged to a reversible Decision Ledger.
• Output: a running app + docs/zeus/zeus-report.md (SUCCESS requires proved evidence for planning, implementation, inspection, runtime setup, and tests).
• Next: review the Decision Ledger.

/chronos — Tireless fix loop (Time)

• When: "fix everything in X until tests pass" — autonomous and resumable.
• Use: /chronos [scope] --completion-promise '...' (aliases: 크로노스)
• Process: FIND → FIX → VERIFY (a real test run, not self-judgment) per cycle, priority-ordered, one issue per cycle; blocked issues are parked with an Owner Decision Brief, with a capability-escalation step before parking. When the scope has a checklist.md, its AC rows are the requirements and progress goes to the shared ledger.
• Output: fixes + docs/chronos/chronos-log.md audit log (the loop resumes from the log, not memory).
• Next: —

mnemo — Cross-CLI memory (Keeper)

Project-skill improvement (v6.12.0). At handoff, Mnemo reviews current-session lessons and failures, then records candidates only for confirmed project-local skills. A separate evaluation compares a bounded change against the original with held-out inputs and regression checks, recording accepted, rejected, deferred, or not-run outcomes. The current LLM supplies short judgments; no Jev API is required.

The four Mnemo adapters bundle these dedicated procedures, so standalone installation does not require the shared skill-evolve, autoresearch, or memory-distill skills. Those shared skills remain available to their other callers. Run install.bat on Windows or bash install.sh on macOS/Linux to update the library; installation locations are listed above. Project instruction-block auto-initialization and doctor integration for improvement candidates are not implemented yet. Installed handoff tools have been tested on all four adapters; LLM improvement quality has not been measured.

• When: always — and whenever you ask "what did we do before?"
• Use: mnemo (aliases: 므네모); auto-saves every turn via hooks. Opt-out: MNEMO_DISABLE=1 (version check: OLYMPUS_UPDATE_CHECK_DISABLE=1).
• Process: 3-layer memory across sessions and Claude/Codex/Antigravity/Grok, with Devin sharing Claude Mnemo; conversational recall; auto handoff near the context limit.
• Output: MEMORY.md (index, ≤100 lines) + memory/<category>/NNN-slug.md with an index.md per category (semantic, one file per entry) + conversations/*.md (episodic) + docs/handoffs/*.md (session boundary — the input port for memory).
• Next: when memory feels stale, run mnemo_doctor.py --chart; the workflow below says what runs when.

Mnemo workflow — what runs when

When	What happens	Tool	Needs Python
Every turn (automatic)	Save the prompt, the reply, and tool observations; classify observations by error shape, not by the word "error"; rotate logs at 10 MB while preserving the distill baseline	hooks (PowerShell / bash)	no
When you ask about a past conversation	Search tags, titles, and bodies; return questions with their responses, linked decisions, and evidence within an output budget	recall.py (read-only)	yes
Right after you edit a file (automatic)	"Which decisions rest on this file?" is delivered to the model as hook context, once per file per session. No lookup is requested and none is typed — knowing which trunk you are on becomes reading, not judgement	save-tool-use (Claude, Grok) · antigravity-hook (Antigravity)	no
Before touching a file (manual)	The same question on demand, plus "when, why, and how did this file change?" from handoffs. "Nothing found" is a valid answer — it may be a new trunk	build_anchor_index.py --file X, harvest_lineage.py --file X	yes
When a decision crystallizes	The entry is born holding its evidence: evidence: (conversation file + turn time), alternatives: (what lost and why, and what would bring it back), depends-on:, sources:, files:. Written then, not later — the moment you know both the old and the new state is the only one	agent, by rule	no
End of session	The agent supplies the verified request and evidence with --origin and --origin-source (both required together); absent evidence stays TODO, and previous handoffs are linked only with --continues-from. The scaffold fills Files Modified from the observation log (only that session's when the origin evidence names session <uuid>), and offers the existing entries that rest on the files you touched as supersede candidates; it also rebuilds the anchor index for every CLI, and in projects with a TermSnap component map it reports this session's unowned files. Then validate: a supersede target that does not exist is a gate; decisions that never reached memory, and entries this session touched whose number never reached its tag line (arch:NNN, , , colon form only), and component-map findings left neither assigned nor deferred, are warnings

Rules that hold it together: memory is project-local; links between entries use entry numbers ([[041-…]], g:072) while tags stay for search. A plain Doctor diagnosis writes no files. Repairs, upgrades, structural promotion, and visit records require explicit flags; upgrades and structural promotion back up original files. Verified, unambiguous references can be repaired mechanically; lifecycle decisions and conditions for reconsidering them remain with the agent and user.

The thread that ties it together. A memory entry is a claim; the conversation is its evidence; nothing used to link them. So the entry ID is now the key: the conversation tag line carries arch:NNN (or learned:NNN, gotcha:NNN), the entry carries files:, and a derived index turns that around so a file can name the decisions resting on it. Hooks deliver that index the moment you edit, on Claude, Grok and Antigravity — three runtimes, three different mechanisms (additionalContext, the same schema again, and injectSteps behind a two-stage relay), one experience. Codex has only a turn-level notify, so it gets the rule and the scaffold instead; capture and linking work there, only the automatic nudge is missing. All four CLIs write conversations into the same project store, which is why that is the part worth guaranteeing first.

Conversational context and existing memories. Mnemo also recalls ordinary chat: preferences, promises, reasons, and changed conditions. It searches tags, titles, and bodies without embeddings or a vector database; a code map is optional for programming tasks. The shared read-only recall.py returns questions with their responses and follows replacement decisions, dependencies, and evidence links within an output budget. The current agent supplies keywords and synonyms and judges whether the evidence still applies.

The existing Doctor now includes --upgrade-memory. It repairs unambiguous existing references in place and promotes explicit conversation links to evidence:, backing up the original bytes while preserving entry IDs, dates, authors, and lifecycle decisions. Unresolved references remain for review. The original --fix repairs retain their scope; upgrades are a separate explicit command.

From the repository root, with Python 3 and Node.js:

# Read-only recall and diagnosis
python -B -X utf8 skills/mnemo/scripts/recall.py --project-root . --term "preferences" --term "promises" --max-chars 12000
python -B -X utf8 skills/mnemo/scripts/mnemo_doctor.py --project-root .

# Modify existing memories with original-file backups
python -B -X utf8 skills/mnemo/scripts/mnemo_doctor.py --project-root . --upgrade-memory

All five CLIs use the common recall and Doctor helpers:

CLI	Mnemo package
Claude Code	mnemo
Codex CLI	codex-mnemo
Antigravity CLI	antigravity-mnemo
Grok Build	grok-mnemo on the Claude compatibility surface
Devin CLI	Shared Claude mnemo, with Devin-native capture hooks

Update with install.bat on Windows or bash install.sh on macOS/Linux. See the recall contract, upgrade contract, and 2026-10-05 verification: 243 Python tests and 25 Node tests passed, with installed-package checks and a Devin producer integration test using a session-database fixture. Final LLM answer accuracy was not measured, and a new live Devin model turn was not run in that validation.

For the four integrated CLIs, hooks keep saving turns with Node.js without Python; write the handoff by hand from skills/mnemo/references/handoff-template.md. Devin assistant capture requires Python 3. Details: skills/mnemo/SKILL.md · skills/mnemo/docs/memory-hygiene.md.

---

Cross-CLI Support

One source library and the same user-facing workflows, with runtime-native defaults for each CLI. The four columns below are the native Olympus support tier: they have an installer target plus runtime-specific policy or adapters, not merely a readable SKILL.md.

Feature	Claude Code	Codex CLI	Antigravity CLI	Grok Build
Skills	22 active in ~/.claude/skills/	21 active in ~/.codex/skills/	21 active in ~/.gemini/antigravity-cli/skills/	same 22 from Claude compatibility layer
Custom agents	none by default (~/.claude/agents/ only on opt-in)	none by default; Codex requires .toml	none by default (~/.gemini/config/agents/ only on opt-in)	none from Olympus by default
Memory (Mnemo)	save-response hook	save-turn hook	native Stop hook	grok-mnemo hook
Gotchas/Learned	save-tool-use hook	save-turn hook	turn-level Stop hook	grok-mnemo hook
Orchestration	native workers; optional MCP	native workers; optional MCP	native workers; optional MCP	native workers; MCP PM host only
Install	no-argument installer prepares assets; CLI commands run when claude exists	same installer prepares assets; MCP commands run when codex exists	same installer writes skills, hooks, and mcp_config.json; agy is needed only to run Antigravity	shared Claude assets; grok-mnemo runs when Grok home exists

Devin CLI: Claude skills with native Mnemo hooks

Devin reads the Claude Code skill directory, including /mnemo. The detected-CLI install adds only Devin-specific conversation capture and a small rule block; it does not add a fifth full Olympus sync target or claim MCP, agent, or workflow parity. Native hooks save user prompts and assistant replies under the same project conversations/ store used by the four integrated CLIs. Python 3 reads assistant text from Devin's local session database. This capture was verified with Devin CLI 3000.11.3 on Windows; macOS and Linux runtime capture is not yet verified. See the adapter and verification steps.

Portable Agent Skills hosts

The hosts below implement Agent Skills, but Olympus does not yet claim end-to-end runtime support for them. A skill being discoverable does not prove that its scripts, slash aliases, hooks, permissions, subagent delegation, or completion loop behave the same way.

Host	What is portable now	What is still missing for Olympus parity
OpenCode	Reads standard skills from ~/.claude/skills and .agents/skills	Dedicated install policy, aliases, hooks/Mnemo, MCP, and native-worker verification
Cursor	Reads local Claude and Codex skill directories as compatibility sources	Dedicated install policy, aliases, hooks/Mnemo, MCP, and overlap audit against Cursor built-ins
GitHub Copilot	Supports standard project and personal Agent Skills	The current global Claude install is not a Copilot personal root; installer, aliases, hooks/Mnemo, and orchestration adapters are absent
Pi	Implements Agent Skills and can be configured to read Claude/Codex roots	No default install target or runtime adapter; explicit invocation uses Pi's /skill:<name> form
Hermes Agent	install-hermes.* installs 19 active skills and the source catalog under ~/.hermes	Olympus aliases, plugins/hooks/Mnemo, MCP, and orchestration mapping are absent
OpenClaw	install-openclaw.* installs 19 active skills and the source catalog under ~/.openclaw	Plugin packaging, Olympus aliases, hooks/Mnemo, MCP, and native-subagent verification are absent

The accurate short claim is therefore: integrated on Claude Code, Codex CLI, Antigravity CLI, and Grok Build; Claude skill compatibility and native Mnemo conversation capture on Devin CLI; skills-only installation on OpenClaw and Hermes Agent; portable skill bodies for other Agent Skills hosts. Paperthin's broader "on any agent" wording describes a lightweight skill-format surface; it would overstate Olympus's hooked, stateful harness today.

Cross-CLI sync is handled by sync-claude-skills.js, sync-codex-assets.js, sync-antigravity-assets.js, and the skills-only sync-portable-skills.js. Codex skills install globally only by default, avoiding duplicate discovery from this repo's .agents/skills; use node scripts/sync-codex-assets.js --include-project-skills only for an isolated project-mirror test. All runtimes use a fail-closed skill allowlist. Its cross-runtime union contains 25 skills: 19 user entry points and 6 agent-team/mnemo adapters. Each runtime excludes 3 or 4 incompatible adapters, leaving Claude with 22 active skills and Codex/Antigravity/standalone Grok with 21; the installed Grok surface reads Claude's shared 22. The same 78 public non-allowlisted sources are copied to the non-scanned .olympus/source-skills library and listed as source-only with an exact path in SKILLS-CATALOG.md. The source-only orchestrator also has a non-discoverable executable mirror under .olympus/runtime-modules/orchestrator; MCP registration points there and dependency caches survive source refreshes. Activate every compatible source-only skill with --include-source-only-skills, or only the legacy eight coding guides with --include-broad-coding-skills. Source-only skills can be requested in natural language through the catalog; use the full opt-in when a native /skill-name menu entry is required, because some CLIs reject unknown slash names before model routing. Directories whose names match this repository's skill sources are installer-managed and may be replaced or removed on sync; unrelated local skill names are preserved. Customize the repository source or use a distinct local name instead of editing an installed Olympus copy in place. No custom agents ship to any runtime surface. The retired --include-source-only-agents, --include-project-agents, --include-passive-agents and --include-broad-coding-agents options are still accepted so existing scripts keep working, and they install nothing.

Agent-using skills keep their orchestration logic and map semantic roles to each CLI's built-ins:

Semantic role	Claude	Codex	Antigravity	Grok
Read-only exploration	Explore	explorer	research	explore
File changes and commands	general-purpose / named teammate	worker	Main or an explicitly defined write-capable agent	general-purpose

The main context owns shared state and completion decisions. Workers get a unique file or return-only task; when delegation is unavailable or brings no parallel benefit, the same workflow runs sequentially in the main context.

---

Memory System (Mnemo)

3-layer persistent memory that survives across sessions and CLIs.

Session A: work → #tags saved → automatic or explicit handoff → MEMORY.md updated
Session B: check/read MEMORY.md → past search → context restored

Layer	Storage	Loaded
Index	MEMORY.md	Read first if not loaded (≤ 100 lines / 5 KB)
Semantic	memory/*.md	On demand
Episodic	conversations/*.md	On search

Includes deterministic gotcha/learned capture:

• Errors → hooks append scrubbed events to memory/gotchas/observations.jsonl
• Successes → hooks append scrubbed events to memory/learned/observations.jsonl
• Distillation → session handoffs use the bundled Mnemo session-learning.md procedure for new observations from the current session; explicit backlog rebuilds use the source-only memory-distill module. There is no always-on analyzer agent
• Backlog diagnosis → observation logs are append-only and never truncated; backlog is judged by delta against the .mnemo-distill-offset marker (hooks handle this via .mnemo-status.md), never by cumulative line count

---

What's Inside

Skill sources (103; default union 25, 21 or 22 active per installed surface)

The table is the source inventory, not the startup registry. Low-frequency format tools, provider integrations, framework cookbooks, and generators remain source-only until explicitly invoked through the catalog or installed with the opt-in flag.

Category	Skills	Highlights
AI Tools	codex, antigravity, orchestrator, workpm, agent-team + 5 more	Multi-AI orchestration, PM-Worker pattern
Pipeline	zephermine, zeus, argos, minos, closer, shipping-and-launch	Zero-interaction full dev pipeline, launch checklist
Frontend	react-dev, frontend-design, theme-factory, stitch, seo-audit, ui-ux-auditor, data-visualization + 5 more	9 palettes, 47 font pairings, 84 styles, 14 themes (4 Hangul), SEO+AEO+GEO dual-score audit (search / AI visibility), chart selection guide
Development	docker-deploy, database-schema-designer, deprecation-and-migration, documentation-and-adrs, social-login, code-reviewer + 7 more	Docker, DB design, ADR, migration, social login, code quality
Business	biz-strategy, ceo, estimate, okr, daily-meeting-update	CEO coaching, cost estimation, OKR, standup
Testing	minos, auto-continue-loop, flow-verifier, themis + 3 more	Chronos loop, Playwright QA, privacy-policy generator (Themis)
Memory	mnemo, devin-mnemo, memory-compact, project-gotchas, memory-distill, recipe	3-layer memory, Devin conversation hooks, raw distillation (rebuild), cross-project code recipes (recipe.md + runnable sample, private ~/code-recipes)
Docs	mermaid-diagrams, diagram-design, marp-slide, docx, pdf, draw-io, domain-dictionary + 3 more	Diagrams, editorial diagram rendering (.mmd → branded HTML+SVG, vendored from cathrynlavery/diagram-design MIT), presentations, documents, domain dictionary (DDD UL)
Meta	autoresearch, skill-judge, manage-skills, plugin-forge, release-notes + 4 more	Skill auto-optimization (Hill Climbing, judged on holdout inputs), management, release
Git	commit-work, release-notes, deploymonitor	Conventional commits, CHANGELOG
Media	video-maker	Script → TTS → composition → captions → render on Remotion (React/TSX) or HyperFrames (HTML/CSS/GSAP), one engine per project. Brief types for narrated videos, unnarrated motion shorts, and app promos (a Capture stage records real screens and stops instead of faking UI). Pluggable TTS (Typecast, HeyGen, ElevenLabs, Gemini, Edge TTS, Kokoro) with Korean-safe defaults; freeze-frame and loudness checks in render QA

Agents (none ship)

No custom agents ship. Normal delegation uses each CLI's native subagents; procedural behavior lives in skills, and a skill's own rules live in its references/. The reference agents that used to live in agents/ and the two skill-owned compatibility prompts were removed together with the agent install pipeline: none was installed, read by a skill, or spawned after v5.0.0. Installing again moves Olympus agent copies left by older versions to _pruned-stale-olympus/ and deletes the generated AGENTS-CATALOG.md.

Hooks (9)

Hook	Event	Purpose
reconcile-conversations	SessionStart	Backfill missed Claude/Codex turns from JSONL transcripts
save-response	Stop	Auto-save assistant responses with #tags
save-tool-use	PostToolUse	Tool logging + gotchas/learned observation
save-conversation	UserPromptSubmit	Persist user input
check-new-file	PreToolUse	Reducing entropy check
protect-files	PreToolUse	Sensitive file protection
validate-api	PostToolUse	API file validation
loop-stop	Stop	Chronos auto-iteration
orchestrator-detector	UserPromptSubmit	PM/Worker mode detection

---

Native and Multi-AI Orchestration

By default, workpm distributes work to the current CLI's native workers. The MCP policy layer is only for hard file locks, an external task board, or a deliberate Claude + Codex + Antigravity mix.

Default:             /workpm → analyze → native workers → verify

Optional MCP mode:
Terminal 1 (PM):     /daedalus --mcp → create provider-aware tasks
Terminal 2 (Claude): /pmworker → claim Claude/agnostic task → complete
Terminal 3 (Codex):  /pmworker → claim Codex/agnostic task → complete
Terminal 4 (Antigravity): /pmworker → claim Antigravity/agnostic task → complete

Component	Description
workpm	Default PM entrypoint using the current CLI's native workers
Orchestrator MCP	Optional SQLite WAL task queue, provider routing, file locks, dependency resolution
pmworker	Worker entrypoint for the explicit MCP mode (Claude/Codex/Antigravity)

---

Ecosystem and credits

Olympus uses the open SKILL.md model and learns from the broader agent-skills ecosystem:

• Agent Skills specification — portable skill structure
• Anthropic Skills — official examples and complex document workflows
• Vercel skills CLI — cross-agent discovery and installation ecosystem
• Superpowers — methodology-first agent workflows
• Paperthin — low-level, cross-agent design patterns
• humanizer — English AI-writing patterns behind the humanizer skill
• im-not-ai — Korean AI-writing taxonomy and corpus measurements behind the humanizer's Korean module

Vendored components keep their upstream license files inside the relevant skill directories.

---

Documentation

• Setup and installer options
• Workflow guide
• Skill registry and collision recovery
• Changelog

Contributing

Issues and pull requests are welcome. Before opening a PR, read AGENTS.md, keep one canonical skill source under skills/, and run the repository tests.

$tests = (Get-ChildItem scripts/tests -Filter '*.test.js').FullName
node --test $tests

node --test scripts/tests/*.test.js

If Olympus saves you a planning pass, a failed handoff, or a debugging loop, starring the repository helps other solo builders find it.

---

Korean GS certification preflight

gs-certification prepares a product for Korea's GS (Good Software) certification through an explicit, optional workflow. It separates grades 1 and 2 and connects requirements, product documentation, executable tests, defects, and regression evidence. It does not run automatically during ordinary development.

Install and invoke

# Windows: synchronize Claude, Codex, Antigravity, and Grok
install.bat --all

# macOS/Linux/Git Bash
bash install.sh

The default installation keeps this skill source-only, discoverable through each CLI's skill catalog. Grok shares Claude's installation surface. A default slash registration is not required or assumed. From the product project, request:

Run a Korean GS grade 1 certification preflight.
Check readiness for Korean GS grade 2; do not modify product code.
Prepare for Korean GS grade 1, fix the findings, and run regression tests.

The workflow asks for a missing grade. Grade 1 quality evaluation and grade 2 quality/business-suitability evaluation use separate profiles and results. The selected institution, criteria revision, build, and environment are recorded. A check-only request does not authorize product changes or external submission.

ISO basis and execution

The TTA service description identifies ISO/IEC 25023 (quality measurement), 25041 (evaluation guidance), and 25051 (product/documentation requirements and testing). The workflow resolves actual criteria, measurement methods, and thresholds from the selected institution's current grade- and product-specific requirements.

Scope and criteria → measurement/test design → execution → defects and regression → documentation/evidence audit → readiness report

Owner	Responsibility when GS preflight is requested
GS skill	Criteria mapping, grade-specific plans, evidence and defect ledgers, readiness decision
Code reviewer	Server authorization, input/business validation, meaningful test assertions
api-tester / Minos	Positive, negative, boundary, direct API, and regression tests
Clio	Product description and user manual review, documented procedure reproduction
Argos	Criteria, measurements, execution evidence, documentation, and defect closure audit

Only the required modules run. The workflow does not automatically run Hestia cleanup or every installed skill. A Python runner executes reviewed project test commands and records timestamps, exit codes, and output hashes. EVIDENCE_COMPLETE means automated evidence collection is complete; Argos must review it before READY.

Outputs and limits

Artifacts go under docs/gs-certification/grade-{1|2}/{run-id}/: criteria, test plans, execution evidence, document reviews, defects, and audit results. READY / NEEDS_WORK / INCOMPLETE are internal preflight decisions, not official certification or accredited test reports. Missing criteria, equipment, accounts, or evidence remain unverified.

The loopback HTTP fixture verifies authorization/input defects, denied-write side effects, grade gaps, grade-2 business assertions, timeouts, and preservation of previous evidence. It does not certify a real product or every ISO clause. Crash recovery, persistent data after restart, and database restoration still require product-specific tests and are not covered by the sample.

Skill · Execution protocol · Sources

License

MIT

---

Last Updated: 2026-10-30