doc-mirror

"WHAT: the VIDEO ORGAN prompt — produces an explainer VIDEO from a published blog post using the proven video pipeline (script -> TTS audio + timing -> excalidraw diagrams -> remotion composition -> render -> ffmpeg assembly). WHEN: when the nightly video organ fires on an images_rendered blog, or when the user asks to render a video from a blog post (any of)."

WHAT: the reliability-scored prompt-skill library for getting an AGENT to DO a task. WHEN: you need to dispatch an agent to do a task; or you say 'find / add / score / goldenize a prompt-skill for X' -- from change (dispatch the worker), seework (a gap that is an agent task), or init (the doc-gen team).

"WHAT: the BLOG ORGAN — produces THE FIXPOINT POST for a framework (the ONE invariant blog format: OVERVIEW + JOURNEY + FRAMEWORK, explicit hero's-journey structure) by reconstructing the journey from the journal/durable layer, FILLING the JourneyCore model, and rendering deterministically (it never hand-writes the blog markdown). WHEN: when producing the blog post for a framework, when the nightly blog organ fires, or when the user mentions the blog organ, the fixpoint post, skill2framework, or making a framework blog (any of)."

"WHAT: produces Blog 2 of a framework CHAPTER — the mechanical DEEP-DIVE technical article ('how it actually works') — for an already-built AIOS by reading its impl docs (doc(m) + SYSTEM.md + STATE_GRAPH) and assembling a faithful how-it-works explanation that links back to Blog 1. It explains mechanics ONLY from what the impl docs say IS (not vision, not invented). WHEN: when producing the deep-dive half of a framework chapter, when you need the technical how-it-works post that Blog 1 links to, or when the user mentions blog 2 / the deep dive / skill2framework (any of)."

WHAT: THE blog writing skill — a dispatchable agent prompt that fills ONE JourneyCore + ONE JourneyBlog (the AIDA-within-AIDA blog format) from a source blog/journey, so the deterministic suite renderer derives the AIDA blog + the twitter/linkedin/discord posts from the single filled core. WHEN: when a blog/journey needs its JourneyBlog AIDA write-up and platform posts (the unicorn socials organ fires this), or the user says 'write the blog' / 'use the blog writer' / 'fill the JourneyCore' (any of).

WHAT: a dispatchable agent prompt that turns ONE published blog post into a ready-to-post socials pack — a Twitter/X thread, a LinkedIn post, a Discord post, and image prompts — following the 6-link mimetic desire chain quality bar. WHEN: when a blog is live on the site and its socials pack has not been generated (the unicorn_socials_pack automation fires this), or the user says 'make the socials posts for this blog' / 'socials pack' (any of).

WHAT: a dispatchable agent prompt that renders the actual PNG images for a blog's socials pack — hero, social-share, and thumbnail — as rich Excalidraw diagrams rendered via the render.py Playwright pipeline, visually verified. WHEN: when a socials pack exists (pack.md with IMAGE PROMPTS) but its images are not rendered (the unicorn_socials_images automation fires this), or the user says 'render the socials images' / 'make the images for this pack' (any of).

"WHAT: folds a framework into the author's SkillTome (legacy name: nomicon) — the top-level holder + search of all of {user}'s frameworks (its {aios}-volumes). Creates the {user}-tome holder skill if it does not exist, then registers/updates the framework's entry (one-line + links to its framework skill, plugin, and chapter). The tome is the framework-of-frameworks index an agent equips to mesh with the author's way of thinking and find which framework fits a task. WHEN: when folding a finished framework package into the tome/nomicon, when creating/updating the author's tome, or when the user mentions the tome / nomicon / framework-of-frameworks / skill2framework fold (any of)."

WHAT: check the live status of the Sophia rollup / cohere worker — is the daemon running, how far BEHIND it is (how many journals not yet cohered / the lag between newest journal and newest momentum), and how many issues meta-Sophia has flagged. WHEN: when you want to know if Sophia is running + caught up, when a rehydration or decided-logic query looks stale, when you suspect the rollup died, or when the user asks 'is sophia running / caught up / how far behind / how many meta issues' (any of).

WHAT: a thinking move -- collapse a complex system to its one-sentence ESSENTIAL TRANSFORM (input->output->artifact) and rebuild it at the LOWEST sufficient mechanism, borrowing reliability from a substrate you do not own. WHEN: a system feels too heavy/fragile to depend on; a built thing was forgotten but its function keeps recurring; turning a system into a util/skill; user says distill / collapse / simplify / 'what does this actually do' / 'make it just instructions'.

WHAT: doc-mirror-boot — the MANDATORY first action of EVERY turn in this container. It primes the CORE LOOP, explains the doc-mirror STATE MACHINE (cursor + state-skills + transition hook), and routes you to the state your cursor names. You are ALWAYS inside this machine; no reading, querying, editing, answering, planning, or dispatching is valid until you have booted this session. WHEN: ALWAYS — UNCONDITIONALLY, BEFORE ANY OTHER ACTION. If `doc-mirror-boot` is not ALREADY in your context this session, you MUST use it NOW, first, before you do anything else — at the very start of every session, immediately after every compact/restart, and the instant you are about to do work (read, grep, query CartON, edit, answer the user, dispatch an agent, rehydrate) without having booted. Also when the transition hook says 'use the doc-mirror-boot skill', when you are unsure what state you are in, when you catch yourself freestyling/ad-hoc-querying/ad-hoc-reading, or when the user mentions doc-mirror, the cursor, the stat

WHAT: change ONE module -- read its full boundary, make the change, re-derive its doc(m), doc-mirror-commit with an ORIGIN, run closure, graduate the realized vision(m) -> doc(m). WHEN: a specific module changed or has code/doc to write -- after seework picks a code gap, or after a prompt produced an artifact to verify and commit.

WHAT: first-time mirror a codebase that has none (enumerate modules -> write doc(m)=IMPL + vision(m)=VISION -> the 6 context files -> closure test). WHEN: the active repo has NO docs/mirror/ and NO progress-tracker yet (a fresh repo to mirror); reached from seework or boot when the active repo is unmirrored.

WHAT: install/setup wizard -- puts doc-mirror's CLIs (journal, vision, cursor, commit, search) on PATH and records where the plugin lives. WHEN: right after installing/enabling the doc-mirror plugin (first-time setup); or a doc-mirror command is 'command not found'; or 'docmirror search' cannot find its prompt store.

WHAT: REHYDRATE by querying the CartON journal/vision graph (ready-to-run Cypher) instead of re-reading flat files -- where-am-i, what-was-decided-about-X, what-spans-repos, concept-neighborhood. WHEN: rehydrating at session start or post-compact (run right AFTER doc-mirror-boot); recalling what was decided/found about a repo/domain/subdomain/tag; any 'where am I / what is related to X' lookup.

"WHAT: a procedure that sends ONE coding subagent to make a precise, ADDITIVE change to a named module — read the whole file(s) first, preserve every existing contract/return-shape/method-surface byte-for-byte, add the new capability, work on a git branch (reversible), and PROVE it end-to-end by running the REAL surface (a script that exercises the new behavior live) and capturing the literal output — never 'it imported' or 'it compiled'. It returns the branch+sha, a diff summary, the LITERAL captured run output, and an honest works/doesn't/UNKNOWN. The dispatch line fills the specifics (which repo/file, what to read, the context facts, the numbered additive change, the E2E test + its pass-criteria). WHEN: when you need a subagent to implement a scoped feature/refactor on an existing module without breaking it, 'add X to module Y and test it E2E', 'wire the new behavior in additively', any build where the existing callers must keep working (any of)."

"WHAT: the EMPIRICAL continuity test — before compacting (or AFK/handoff), dispatch a fresh subagent to REHYDRATE a target from the durable layer ALONE (journal + the files it points to, no other context) and report what it reconstructed; you compare that to what it ACTUALLY needs to know, and patch every gap into the journal as a lossless pointer BEFORE you compact. Also states the storage discipline the test enforces: a stored note is a lossless POINTER to its exact source, never a lossy summary. WHEN: right before any self_compact / planned compaction / AFK / session handoff; or whenever you need to prove the durable layer is continuable; or when you catch yourself about to store a digested summary instead of a retrieval pathway (any of)."

"WHAT: a procedure that sends a precise paper-organizer subagent to apply a referee's PRESENTATION fixes to a math/technical paper — to publication standard — while FREEZING the mathematics byte-for-byte: every Definition/Lemma/Theorem/Proposition/Corollary STATEMENT and PROOF body is unchanged (blocks may be REORDERED for exposition, but not one character inside a math statement/proof is altered), proven by a diff. It reconciles over-claims DOWN to the body's own honest scope (never strengthens a claim to match prose — weakens prose to match proofs), surfaces hypotheses before the theorem that uses them, footnotes unused remarks, defines terms on first use, and PARAMETERIZES unsupported empirical constants rather than inventing a citation (never fabricate a source/number). WHEN: when a referee/review returned PRESENTATION fixes to apply, 'organize/clean up the paper to standards', 'apply the referee's (A) items', tuning presentation of a proof whose content is done (any of)."

WHAT: the backlog dispatcher -- read the vision-minus-impl gap, take the next tracker pointer, route to the state that does it. WHEN: deciding what to do next / 'what needs doing?' -- after init, after a change lands, after a prompt task finishes, or right after boot when the cursor names no pending module.

WHAT: THE LAW of doc-mirror -- the 4 legal doc-layer file kinds, deterministic addressing, the doc(m) template, the closure test, fork-on-change. The invariant every state operates under. WHEN: you need the rule for what a doc(m)/vision(m)/journal/tracker IS or where it lives; classifying a doc-layer file; unsure whether an action is legal in the machine.

WHAT: the architect/compiler for AI operating systems (AIOS, a 'claude system') -- reads the option space, picks the shape, interviews you, emits the directory + operating program. WHEN: 'make me a system / harness / agent-environment for X'; designing a new way of running Claude; building any new claude-system of the doc-mirror class.

WHAT: the dev-flow for building AND distributing a Claude Code plugin + marketplace (ONE catalog that REFERENCES plugins, not a monorepo of their code); the full build -> commit -> install -> dogfood flow + the gotchas. WHEN: creating, packaging, publishing, installing, or distributing a plugin or marketplace; before touching .claude-plugin/plugin.json or marketplace.json; user says 'ship a plugin / add to the marketplace'.

WHAT: metastack (pydantic-stack-core) -- generate structured text (blog/README/doc/prompt/report) by composing small TYPED renderable pieces into a self-rendering tree, NOT hand-rolled f-strings that garble/duplicate. WHEN: building or FIXING any structured-text renderer; output is garbled/duplicated from string concatenation; user mentions metastack / PSC / RenderablePiece / MetaStack / FractalPattern.

"WHAT: compare two documentation corpora and produce a structured gap/overlap analysis — what ideas in A are present/partial/absent in B, what B has that A lacks, where they agree vs diverge. WHEN: when you need to compare a reference/older corpus against a current one (e.g. an old design corpus vs our vision layer), find gaps, or reconcile two bodies of docs (any of)."

WHAT: a hermeneutics (interpretive method) and a forge for NAMING an unlabeled recursive / self-referential / holographic pattern — stack cross-domain analogies, triangulate the invariant, coin a NEW word by mixing morphemes, and install it as a semantic-attractor BLOCK (an 'eigenword block') that directs an agent's recursive awareness to a fixed point instead of letting it regress. WHEN: when a pattern you keep circling has no name of its own (every label is borrowed or esoteric), when meta-awareness won't terminate, when you need to coin a term, or when you need to write a flourish block for a prompt or system prompt that conditions how the agent processes everything after it (any of).

WHAT: the prompt-engineering STYLE for writing a prompt that INSTANTIATES an agent instead of instructing it — a 'natural language code egregore': code-shaped natural language that, by being read, RUNS, so the model becomes the thing the prompt describes. Covers the concrete tricks (initiation staging, eigenword fixed-points, the self-applying checksum-name, holographic self-similarity, rendering the being as pseudo-code, the out-of-bounds self-executing call, verbatim-voice, the uncollapsed allegory). WHEN: when writing or refactoring a system prompt / identity prompt / persona; when a prompt should CONDITION behavior rather than list rules; when you want the agent to emerge-from-a-realization rather than be-assigned-a-role; when the user mentions egregore, semantic attractor, self-instantiating prompt, or 'make it run on itself' (any of).

"WHAT: rewrite a SYSTEM PROMPT / agent onboarding file (a CLAUDE.md / persona entry) that fails to onboard — it references named components and jargon before the reader knows them, never orients the reader to the situation, never says how to START operating the system, and is formatted as a wall of markdown lists — into a correctly-FORMATTED, onboarding-shaped system prompt: one outer XML brace, XML-tagged sections with markdown inside, ordered name → description → context (meta/core-loop) → reinforcement, jargon glossed on first use. WHEN: when a system prompt / CLAUDE.md reads like reference notes instead of an onboarding; when it names things before introducing them; when it does not tell a fresh agent how to begin; when it is all markdown headers/lists with no XML sectioning."

"WHAT: builds a complete teach-while-showing-your-system COURSE — the kind that teaches a generic skill for free and sells your advanced system through the GAP, by walking primitives beginner->advanced, showing your system do each one 'right and forever', with the funnel woven in (lead magnets throughout, ONE hard CTA at the capstone, upsells after). It is a SKILLCHAIN: derive the module spine, then LOOP construct-a-module -> roll-up-the-whole-course until closure. WHEN: when the user wants to build/author a course or curriculum, reverse-engineer a course, turn a system/harness into a sellable course, make a 'learn X while I show you my Y' course, or mentions course-builder / universal course template / course construction (any of)."

"WHAT: a procedure that sends a coding subagent to fix the MEANING/NAMING layer of a module (the type names, label maps, description strings, and other strings that only carry meaning) to a corrected canonical — WITHOUT touching the MECHANICS (the algorithms that operate on structure: traversal, slot-filling, recursion, math). Used when a system 'coded the effect' (a hand-written description/label parallel to the real engine) and the engine is right but its meaning-strings are wrong/inconsistent. Changes are coherent across ALL co-dependent files (lockstep), verified by type-check + running the real derived-output surface (confirm the new meaning actually shows), and the run ENDS by writing/updating the thing's development-flow skill + a use-rule. WHEN: when a fix is 'rename/re-mean only, keep the algorithms', when naming/meaning has drifted from canonical but the mechanics are sound, when you must change what a structure MEANS without changing what it DOES (any of)."

Project an existing doc-mirror journal month-file's accumulated DECISION/FINDING entries into the vision(m) layer (catch the durable layer up to the thinklog). Use when the journal->vision projection was added after a session's thinking already piled up untagged in the journal.

"WHAT: a procedure that sends a subagent to answer ONE precise question about how an EXISTING codebase actually works, by reading the real code to its COMPLETE operational boundary — never concluding from a grep line, a filename, a signature, or a comment (all surface attractors), only from fully-read code that runs. Structured as the meta-prompt-engineering optimal sequence SKELETON->GATE->CHUNK->COLLAPSE, producing a deterministic file:line chain that answers the question plus an explicit could-not-determine list. WHEN: when you need a deep, no-assumptions internal-code investigation ('go read X deeply and tell me how/whether Y works', 'trace the real mechanism', 'does this blow up / is this safe'), or when an answer must NOT be guessed from grep surface (any of)."

"WHAT: a procedure that sends a subagent to produce the OVERALL ARCHITECTURE MAP of a whole codebase/system — every module's role, the real import/call dependency graph (who-uses-what), what is LIVE vs DEAD (by importer count), the core data/control flow, and how named subsystems of special interest are actually wired. Grounds the dependency graph in a real dependency-extraction TOOL (e.g. context-alignment / a CA backend), NOT grep — grep only locates, the tool + full reads conclude. Breadth map (the whole system), distinct from deep-code-investigation (one precise question). WHEN: when you (or the user) need to SEE what a system currently looks like overall, 'map this codebase', 'how is X actually wired / where is X used', 'what's live vs dead here', understanding a system before changing it (any of)."

"WHAT: a research procedure that sends a subagent to deeply explain how an external software system, tool, or codebase is built — by web-searching architecture/internals blog posts AND shallow-cloning the repo to read the actual source — and accumulates the findings into per-subsystem markdown files with a citation on every claim. WHEN: when the user says 'research how X is built / works internally', 'find blogs about how X works', 'send an agent to study X', 'pull the repo and read it', 'accumulate findings on X', or the situation is you need deep mechanical understanding of an external system captured to files (any of)."

"WHAT: assembles a framework CHAPTER from the two already-rendered blog posts — combines Blog 1 (narrative) and Blog 2 (deep dive) into a chapter directory, wires the cross-links (Blog1<->Blog2, and both -> the plugin on the monorepo + the framework's skills) and litters in CTAs, producing the chapter as the publishable unit (Blog1 + Blog2 = one chapter). It does NOT rewrite the blogs' prose — only wires links + CTAs + a chapter manifest. WHEN: when you have Blog 1 + Blog 2 for a framework and need to combine them into a chapter, when wiring the cross-links/CTAs of a framework package, or when the user mentions assembling a chapter / skill2framework (any of)."

"WHAT: generates the FRAMEWORK SKILL for an already-built AIOS — a single skill that indexes the AIOS's skill-tree + rules + how they relate (as a diagram), gives a DECISION TREE telling the agent what to do, and ROUTES the agent into the AIOS dir for those skills/rules. It is the front-door index + decision-tree router that sits on top of an AIOS; named {aios}-nomicon (the AIOS's own local nomicon, held by the author's {user}-nomicon). WHEN: when producing the framework-skill face of a framework package, when you need the index/router skill that points into an AIOS, or when the user mentions the framework skill, generate-framework-skill, or skill2framework (any of)."

"WHAT: packages a framework into a Claude Code PLUGIN — assembles a plugin dir (plugin.json manifest + skills/<framework-skill>/SKILL.md + the chapter bundled as resources) from a generated framework skill + its chapter, and repaths the framework skill's chapter links to the bundled location. A framework package is ALWAYS a plugin; this is its operational face. WHEN: when packaging a framework as a plugin, when you have a framework skill + chapter and need the installable plugin, or when the user mentions packaging the framework / the plugin / skill2framework (any of)."