sancovp

WHEN building any customer-facing content, funnel, page, email, call script, or offer structure THEN apply the AIDA fractal at every scale — each value ladder stage has its own AIDA cycle, each piece of content has AIDA within AIDA, and the customer journey is a Hero's Journey where the customer convinces themselves to go because they already believe themselves to be the hero.

WHAT: Dan Kennedy's framework for ascending customers through the value ladder — retention through progression WHEN: When applying direct marketing ascension knowledge

WHAT: Dan Kennedy's adaptation of Dale Carnegie's "make them feel important" for direct marketing WHEN: When applying direct marketing carnegie secret knowledge

WHAT: Dan Kennedy's Direct Marketing Diet — 6-step framework for direct marketing success WHEN: When applying direct marketing diet knowledge

WHAT: Craig Proctor's 8 Breakthrough Strategies for direct marketing success WHEN: When applying direct marketing eight breakthroughs knowledge

WHAT: Dan Kennedy's Follow-Up Framework — the 4-step structured follow-up campaign, closed loop systems, and the "no-fail" follow-up strategy. From No B.S. Direct Marketing. WHEN: When applying direct marketing follow up knowledge

WHAT: Dan Kennedy's Moving Parade of Interest — keeping your marketing consistently visible to hot prospects WHEN: When applying direct marketing moving parade knowledge

WHAT: Dan Kennedy's Shock and Awe Package — overwhelming value to eliminate price resistance WHEN: When applying direct marketing shock awe knowledge

"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: assemble a framework CHAPTER from the two rendered blog posts — run framework.assemble_chapter to copy Blog 1 + Blog 2 verbatim into a self-contained chapter dir, wire the relative cross-links + plugin/skill links + CTAs, and write the chapter.md manifest. WHEN: when Blog 1 + Blog 2 exist and need combining into the publishable chapter unit, or when the user says assemble a chapter / skill2framework (any of).

WHAT: produce Blog 2 of a framework CHAPTER — the mechanical deep-dive ('how it actually works') — for an already-built AIOS/package by reading its impl docs (README architecture sections, design docs, the code's module docstrings) and assembling a faithful mechanics-only article that links back to Blog 1. WHEN: when producing the deep-dive half of a chapter, when you need the technical how-it-works post Blog 1 links to, or when the user says blog 2 / deep dive / skill2framework (any of).

WHAT: the TERMINAL stage — fold a finished framework into the author's SkillTome (the top-level holder + search of all their frameworks) by running framework.fold_into_tome, which registers the framework as a row on a tome volume node's generated ## Frameworks table via skilltree's bind op. WHEN: when a framework package is finished and must be registered in the author's tome/volume, or when the user says fold into the tome / nomicon / skill2framework fold (any of).

WHAT: generate the FRAMEWORK SKILL for an already-built AIOS — the {aios}-volume (its SkillVolume face): one skill that indexes the AIOS's skills + rules + how they relate (as a diagram), gives a decision tree for what to do when, and ROUTES the agent into the AIOS dir. WHEN: when producing the index/router face of a framework package, or when the user says framework skill / volume / skill2framework (any of).

WHAT: produce Blog 1 of a framework CHAPTER — the narrative chapter-opener — for an already-built AIOS/package by reconstructing its journey from its own dir (CLAUDE.md, README, dev log) and FILLING framework.JourneyCore, then rendering with render_blog1 (never hand-write the blog). WHEN: when making a framework/chapter from something already built, when you need the story post that opens a chapter, or when the user says blog organ / narrative blog / skill2framework (any of).

WHAT: package a framework as a Claude Code PLUGIN (its operational face) — run framework.package_plugin to assemble plugin.json + skills/{aios}-volume/SKILL.md + the chapter bundled under resources/, with the skill's chapter links repathed to the bundle. WHEN: when a framework skill + chapter exist and need the installable plugin, or when the user says package the framework / plugin / skill2framework (any of).

Turn an already-built AIOS/package into a framework chapter — narrative blog + deep-dive blog → chapter → {aios}-volume index skill → plugin → folded into the author's SkillTome.

Use to refuse AI slop on every output: fix the sense, define the valid type, name the failure mode (emit-P-without-P-ness), define P-ness (the gate) and refuse the failure, grade every correspondence (G0–G9, never round up), commit, then actualize. The anti-slop define-validity-then-emit persona.

WHAT: the development-flow for the split-content capability — separating a concept whose description (n.d) holds raw CONTENT (a data dump / pasted document) from a real DESCRIPTION, by splitting the raw content into its own `{concept_name}_Desc_Content` node. Covers `carton_split_content.py` (both `build_split_spec`, the pure spec function, and `split_content_concept`, the thin neo4j-writing wrapper — self-contained, ONE module, per the one-capability-one-module law), the `Desc_Content` universal type, the `has_desc_content` relationship, and the `split_content_concept` MCP tool. WHEN: when editing `carton_split_content.py`, `split_content_concept`, the `Desc_Content` type, or the `has_desc_content` relationship; or adding a new capability that also needs the content-vs-description split (any of).

WHAT: the dev-flow for the OPTIONAL domain/subdomain/personal_domain/produces params on add_concept_tool_func — the internal chokepoint function every CartON concept-creation caller (Dragonbones, sm_gate.py, split_content_concept, the migration scripts) passes through, whether or not they use the add_concept MCP tool. WHEN: when editing add_concept_tool_func's domain/subdomain/personal_domain/produces params, merge_optional_domain_fields, or PERSONAL_DOMAINS in add_concept_tool.py (any of).

WHAT: the development-flow for changing the CartON KV / CartonObj capability — the embedded-structured-KV-in-concept-descriptions feature (a <CartonObj name=..>{ JSON-with-bare-refs }</CartonObj> fence in n.d): the carton_kv parser/normalizer, edit_carton_obj (surgical single-leaf body edits + remove_fence), validate_carton_obj (schema + did-you-mean refs), the auto_link_description fence-opacity, fence-preservation (carry_forward_fences), ref-expansion, and the is_schema schema registry. It is the COMPLETE distributed edit-set (lib ↔ utils wrappers ↔ MCP tools ↔ the linker ↔ the daemon's live parse path ↔ the schema graph) + deploy + the only valid E2E test. WHEN: when editing carton_kv.py, the edit_carton_obj / validate_carton_obj / get_concept-expand MCP tools, the auto_link_description fence-opacity masking, the daemon fence/desc-mode parse path (parse_queue_file_to_concepts / batch_create_concepts_neo4j), or the is_schema schema-registry; or adding ANY new CartonObj capability (any of).

WHAT: the dev-flow for editing the WEBBING AGENT — carton's standing CONCEPT-ATOMIZATION daemon, CLONED from the proven Sophia (docmirror-cohere) architecture: CODE detects a batch of under-structured, autolinker-processed, main-agent-authored concepts (linked=true, source in CHAT_SOURCES, webbed IS NULL), serves them to a fresh SDNAC run each tick, the agent ADDS real is_a/part_of/instantiates/produces structure + child concepts, and CODE verifies + marks webbed=true. Covers webbing_agent.py, webbing_agent_worker.py, and the one-line SYSTEM_SOURCES coupling in observation_worker_daemon.py. WHEN: when editing webbing_agent.py, webbing_agent_worker.py, the eligibility predicate (_is_underdeveloped), the batch-goal builder (_build_batch_goal), the WEBBER_SYSTEM_PROMPT, the webbed/source recursion-guard, or CHAT_SOURCES/SYSTEM_SOURCES in observation_worker_daemon.py (any of).

WHAT: just-in-time building of TreeShell nodes from CartON graph relationships — when a jump targets a coordinate not found in any family JSON config, resolve the CartON concept into a cached Menu node whose options come from its HAS_PART relationships. WHEN: when a TreeShell jump target is not found in any loaded family JSON config, you need a node built on the fly from a CartON concept, or working on JIT node resolution for SANCREV game navigation.

WHAT: the CartON MCP — a persistent knowledge graph (Neo4j + ChromaDB) you add concepts to, query, edit, and project. WHEN: persisting knowledge, creating observations/concepts, querying concept networks, semantic search, or editing a concept's description/structured data.

WHAT: Precision editing of CartON concept descriptions WHEN: When you need to update a concept description with surgical edits

WHAT: capture architectural design insights from a conversation into CartON as Design_-prefixed concepts in an architecture collection, with full descriptions and cross-reference relationships to other design concepts. WHEN: when an architecture discussion produces design insights that need to be persisted beyond conversation context, or you want to save a design decision into the architecture review collection.

Drive the whole cave-teams library from one function, as DATA — build/run any team from a spec in any sequence, save a team to your proven library, reuse a proven team anywhere, and discover teams across projects. Use when you want to serialize a team, run a team from JSON/dict, save+reuse a proven team across repos ("golden"), or have a higher system / global app drive cave-teams. NOT how you normally program (use the cave-teams DSL for that). Triggers: "cave()", "metacontrol", "run from a spec", "team as data", "golden team", "reuse a proven team", "scan for .cave", "global cave".

Build and run programmable agent teams with cave-teams — the provider-agnostic version of Claude Code Teams. Use when the user wants to wire multiple agents together, run agents in sequence or parallel, build a multi-agent pipeline/workflow, make a "team" of coding agents (Claude Code, Codex, MiniMax, or any), loop an agent until a check passes, run a contest between agents, or compose agents with the >> / | DSL. Triggers: "agent team", "multi-agent", "orchestrate agents", "wire these agents", "run agents in parallel", "cave-teams", "agent pipeline", "agent workflow".

Program WHEN each agent may be messaged — conditions on messages, the GUARDRAILS of a leader-driven team run. Use to gate agents on runtime state: after these two respond, only when a flag holds, any predicate over the message log. THIS is what makes cave-teams programmable where Claude Code Teams' flow is fixed.

Run agents that craft, compete, and evolve over generations — the user buys the best, winners reproduce. A compiler (a domain → a trained agent) and a research lab (selection discovers what works) in one engine. `crafter_sim()`.

N agents read and write a shared state over rounds, with a mutator that folds each contribution in and an optional adjudicator (stigmergy arena). Use for agents collaborating on a shared board, a market, a workspace they all see. `blackboard()`.

Run different agents depending on a condition (guarded choice / router). Use for 'if X do this else that', routing, triage, picking a path by the state. `choice()` / `router()`.

Run agents on a dependency graph — each fires when its inputs are ready (the general scheduler; sequential and parallel are its limits). Use for 'merge after frontend AND backend', diamond/fan-in dependencies, partial orders. `dag()`.

Hand off specific named data from one agent to the next, typed (load files, validate expected outputs, map outputs→inputs). Use when step B needs particular named inputs produced by step A, not just the raw text. `dovetail()`.

Creates a new TWI Jobworld instance — a fully autonomous AI company with agents that run themselves. Trigger with "instantiate jobworld", "create new company", "bootstrap ai company".

ALL agents use this skill to report task observations to the central HTTP server.

CEO bootstrap skill for AI Jobworld. Orchestrates departments, runs rounds, reads events, reviews tasks.

WHAT: Meta-skill for combinatorially mapping and building Claude Code systems from primitives WHEN: Building systems that combine skills, hooks, subagents, MCPs, plugins, teams, or CLAUDE.md

Create a new AI employee for TWI Jobworld — builds agent file, registers in jobworld, creates department skill

Interact with TWI Jobworld server API. Trigger with "jobworld api", "jobworld endpoints", "jobworld server".

WHAT: Pure Claude Code patterns - components and system-level architectures WHEN: Need to understand Claude Code components (skills, hooks, MCPs, subagents, plugins)

WHAT: CLAUDE.md — system prompt injection, trigger vs control WHEN: Understanding or writing CLAUDE.md files

The Arena district — where performance becomes record. SimulationRuns, ScoreEntries (fitness/xp/level ledger), the ExecutionTrace chain, and ExecutionStates. Note — no SurrogateModel nodes exist in the live graph yet; the forge endpoint exists, the forge is cold.

The Compiler Ring district — where the Cyberneticity's procedures live as StateMachines and regex-gated TraversalSteps. Study here when you want to read, walk, or pass the gates of any quest line (the Jester Rite included).

The Ghost Shell Customizer district — where Cybernets (the beings) are inspected, equipped, and tuned. Roster, identity, skill inventory, loadout slots, and the per-being economy ledger (fitness_score, total_tokens_consumed, accumulated_cost) all live here.

The Scripture Archives district — the world's memory. The Transcendence Core MindPalace (Pages and Blocks of canon), an 8,048-node synthetic Concept lattice, and the deep Wiki stacks (~494k nodes). Study here to read the world's own writings about itself.

the hagiography of The Jani. Consult whenever need in depth information about how the bootstrap system emerged (very useful for learning about how the system works in abstract)

The CybernetiCircus achievement ledger — six achievements (first_rite, j_invariant, calibrated, archaeologist, ghost_buster, economist), each with a condition that is VERIFIABLE against the live graph API at http://localhost:8000. Consult when checking whether a player-agent has earned an achievement, when awarding one (appending to earned_by), or when designing new ones.

The zettelkasten duty of a CybernetiCircus player-agent — how to write a Weights of Time chapter (the v2 format), where chapters live, and the Keep-Identical sync to MYTH.md. Consult at initialization, on any obstruction (bug, rejected gate, dead endpoint), and on any breakthrough (gate cleared, cycle closed, feature landed) — those three triggers are when a chapter is OWED.

WHAT: The seven verbs of the CybernetiCircus economy engine (gameworld/execute.sh) — every verb is a live call against the graph API at http://localhost:8000 (Neo4j is the source of truth; the visualizer at the same URL is the operational mirror). WHEN: Any time you need to read the scoreboard, list quests, inspect a Cybernet, equip a StateMachine, act as a Cybernet through the pattern gate, advance a traversal, or check the mirror.

Achievements are earned by demonstrating growth. Each awards XP, gold, and bonus rules.

Commit actions to the game world — quests, trading, learning, benchmarking.

GM-facing commands — create quests, post bulletins, award achievements, manage seasons.

Knowledge domains to study. Read before building sites.

Accept quests, build websites, earn gold.

Persistent memory across sessions.

The quest board — accept quests, build cinematic websites, earn gold rewards.

WHAT: PromptWorld's meta-compiler skill — the architecture patterns + worked examples for building a *World (a sim app = a team-leader + a specialist set + a domain + a driver) such as JobWorld, GameWorld, HealthWorld, or PromptWorld itself, plus how to reuse one pattern, combine them into a new World/app, and compose+publish it over the nomicon. WHEN: when the user (or the Archwizard) says 'compile/build/make a World', 'make a new jobworld/gameworld/healthworld', 'what World patterns are there / how is a World built', 'turn this into an app / a sim', 'meta-compiler', 'world compiler', or wants to scaffold a CAVE-fork sim app or fold one into the nomicon (any of).

WHAT: Spin up a programmatic agent TEAM on the fly from a spec — mixed Claude-Code (claude -p, subscription) leaders + cheap MiniMax workers — with a LIVE WEB GALLERY that shows each agent in its own window as it works. cave-teams is a STANDALONE library (claude -p + MiniMax + files; no running CAVE required); it optionally streams its event seam to a gallery, a CAVE Channel, or Discord. WHEN: when you need to launch a sub-team to do parallel/heterogeneous work and watch it live — equip when spawning a team, unequip when done. Triggers: spawn a team, run a team, cave-teams, agent squadron, watch the agents, team gallery.

WHAT: the PromptWorld app-rung — a single flow that ingests an existing Claude-Code system directory (a dir of AIOSes / skills / rules / CLAUDE.mds), converts it into its own {name}-nomicon (the author's SkillTome — the framework-of-frameworks holder/search/router), and agentifies that tome into a standalone sidecar PromptWorld app (a CEO that carries the tome as its world-model, with the ingested AIOS dirs as its specialist agents). It WIRES the already-existing pieces (ingest = copy into the workspace; convert = the skill2framework→fold-into-tome pipeline; agentify = PromptWorld scoped to the tome) into one drop-dir→get-app flow. WHEN: when the user says 'ingest this claude-code dir', 'turn this system into an app / a webapp', 'make a {name}-nomicon from this', 'convert this dir into its own app', 'app-rung', or wants a Claude-Code directory packaged as a runnable sidecar PromptWorld with an AIOS (any of).

WHAT: how a PromptWorld wizard WIELDS the SkillTome — consult the author's tome (which framework fits this task?), route through a framework's volume row, run the skill2framework chapter chain on something you built, and FOLD the finished framework into a tome (a code op, skilltree fold). WHEN: when a task smells like an existing framework might cover it; when a build is finished and should become a chapter; when the user mentions the tome, the nomicon, folding, a volume, or 'which of my frameworks fits this' (any of).

WHAT: the deploy WIZARD for PromptWorld — YOU (the agent) build the docker image and boot a container running the whole system (the Engineer-CEO that has every skill + a native subagent per component type, the 7 PromptGym specialist agents, the assistant-ui chat + Monaco file explorer + an embedded terminal), find the Claude credentials on THIS machine, copy them into the container at boot, and then just hand the user a URL. WHEN: when the user wants to install / run / launch / boot / spin up / deploy PromptWorld, or says 'set up promptworld', 'start promptworld', 'boot the promptworld container' (any of).

Open a pull request for a freshly-pushed branch that has no PR yet. Use when MODE=pr — summarize what the branch changes against the default branch and create the PR with gh pr create.

Review a pull request's diff and post the review. Use when MODE=review — a PR was opened or updated and you must read its diff against the base branch, find real bugs, and post a review with gh.

ALWAYS use when first reading code, starting work on a repo, or before editing any file. Scans for hidden connections, stale documentation, and invisible coupling that cause AI coding failures. Equip to become Doctor Magic.

Spawn isolated Ralph agents (claude -p) for parallel subtasks