# Mind Clone > mind-clone — a clone of how an author thinks, from public content - Skill: `mrgnfndr-dr/mind-clone` (Agent Skill, multi-file: 8 files) - Install (CLI): `npx skillmds@latest add mrgnfndr-dr/mind-clone` - Raw SKILL.md: https://api.skillmd.com/api/skills/mrgnfndr-dr/mind-clone/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: mrgnfndr-dr (https://skillmd.com/u/mrgnfndr-dr) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/mrgnfndr-dr/mind-clone --- # mind-clone — a clone of how an author thinks, from public content This skill builds a **cognitive model** ("mind clone") of a real author from their public footprint, persists everything as a local database in the user's project, and then answers questions, gives advice, and predicts positions **the way that author would think** — not by imitating their tone, but by reasoning through their actual mental models. The clone is an **interpretive model built from public sources**, not the real person. It must always label predictions as predictions and never fabricate quotes. See `reference/ethics.md`. --- ## Two modes — route first On invocation, decide which mode applies: | Signal | Mode | Go to | |---|---|---| | "Build / create a clone of X", no clone exists yet for X | **BUILD** | Pipeline below | | A clone folder already exists and the user asks a question, wants advice, or "what would X think about…" | **CHAT** | `reference/04-clone-runtime.md` | | Unclear | Ask: build a new clone, or talk to an existing one? List clones found in `./clones/`. | Check `./clones/` (in the current working directory) for existing clones before deciding. --- ## Step 0 — Environment manifest (read before anything, both modes) Before discovery, harvesting, or chatting, **read `ENVIRONMENT.md`** in this skill's directory — the per-machine manifest of where tools live, the OS/path layout, and the proven build/chat commands for *this* user. It exists so you don't re-probe the OS or hunt for libraries every session. - **Missing `ENVIRONMENT.md`?** (first run on a new machine) — run `python scripts/setup.py`: it creates the manifest from `ENVIRONMENT.template.md`, auto-detects tools/paths, and prints the welcome message to show the user. Fill in the prose sections as you learn the machine. - **Stale after installing/removing a tool?** — re-run `python scripts/setup.py` (or `bash scripts/probe_env.sh --write`). - `ENVIRONMENT.md` is git-ignored, so it stays local and survives skill updates. - Append every environment trap you hit to its "Known quirks" section, so the next session skips the dead-end. --- ## Step 1 — Language protocol (always first, both modes) 1. On the **first interaction of a session**, ask the user which language they want to converse in (offer the language their message is in + English). 2. Store the choice in the clone's `config.json` (`"chat_language"`). On later sessions, read it and skip the question. 3. **Always converse in the user's chosen language.** 4. **All persisted artifacts** (the database, cognitive model, source tables, this skill's files) are written in **English** regardless of chat language — so the clone is portable and shareable. Translate to the user's language only in the live conversation. 5. **In CHAT mode, the author's quotes display in the user's language too** — lead with a faithful translation, but **always keep the verbatim original alongside** (the deep-link verifies the original). Never present a translation alone as a verbatim quote. See `reference/language.md` → "Quoting the author in CHAT mode". Full rules: `reference/language.md`. --- ## BUILD pipeline (5 phases) Run phases in order. Each writes to `./clones//`. Load the linked reference at the start of each phase. Tell the user what you're doing between phases; don't run silently for minutes. ### Phase 1 — DISCOVERY (exhaustive search) Load **`reference/01-discovery.md`**. Enumerate name variants and affiliations, then run a multi-modal web sweep (articles, YouTube, podcasts, radio, talks, interviews, social, papers). Goal: find *everything* public, not the top 10 links. Deduplicate into a source registry. → emits `meta` rows (a transient delta) → `loop.py import ` (validated on write → log) ### Phase 2 — SOURCE TABLE (review gate) Present the user a table of every source found: **Date · Type · Source · Summary · URL** via `loop.py render sources`. This is the review checkpoint — the user can prune, add, or approve before the expensive harvest. → `render sources` (JIT view from `meta`; nothing stored) ### Phase 3 — HARVEST (extract-on-the-fly) Load **`reference/02-harvest.md`**. Default is **fast**: read each source once and extract the distillate as **EP points** (a transient delta `.jsonl`, thrown away after `import`) — dated, attributed, grounded quotes (`text`) + their group/vector/relation — **and save the raw transcript/text to `raw/` by default** (text is cheap — tens of MB even for a big channel — and it powers deep-links + CHAT-mode live-grounding fallback). **Capture timestamps** (`t_start` in seconds + a ready `deeplink`) for every audio/video quote so the clone can later cite the author verbatim and link to the exact minute; text quotes store the plain URL. Use existing text/captions/transcripts only (fast); **no slow ASR by default**. Articles via WebFetch, YouTube via yt-dlp captions. - Sources with **no subtitles/transcript** → collect them, **show the user a table** (Type · Title · Source · Duration · URL) and **ask** whether to run whisper (slow). Note that a few missing files rarely shift the reasoning model. Run whisper only on opt-in (all / selected). - **Books** → processed **chapter by chapter** (extract-on-the-fly, so volume is fine — the book collapses into distilled evidence, not stored whole). Use a user-supplied legally-owned file or public material only; cite by chapter/page (no deep-link). Often the richest playbook source. Never pirate. - **Raw transcripts/text are saved by default** (`raw/.srt` + `raw/.md`); no flag needed. **Books are the one exception** — only the per-chapter distillate is kept by default (size + copyright); `--archive-raw` opts into keeping more book text. - **Report every gap — never leave a silent one.** - **Write through the contour:** emit each source's EP points as a transient delta and run `loop.py import ` — validation-on-write (CHECK `kind` / FK `meta_id` / NOT NULL) rejects bad rows with a reason and **logs** loaded/rejected. The delta is throwaway; the canon is the `ep` table. From here the data is reached only through the contour. → `ep` rows in `clone.db` (via `import` → log) + `raw/.srt`/`raw/.md` (books excepted) ### Phase 4 — COGNITIVE MODEL (the brain) Load **`reference/03-cognitive-model.md`**. Mine the corpus **via the contour** (`fts` / `map` / `render brain` — never dump the whole table) and enrich each EP point with its **relation overlay** (`subject –relation→ object`) and its `group`/`vector` placement, so the belief graph, frameworks, heuristics, stances, antipatterns, and reasoning chains are all just typed relations *on the EP points* — each already grounded by its own `text` + `backing` + deep-link. **Keep it lean**: the relation overlay is a thin index; the heavy lifting is answer-time retrieval + live-grounding. **Tag each EP with a confidence weight (`H/M/L`) and, when time-bound, `as_of `.** Refine grouping/relations incrementally via the EP append-only pipeline (a reconciled *delta*), not a full rebuild. → enriches `ep` rows (relation overlay + group/vector + confidence). The brain is `render brain`, not a stored file. Voice/register notes → `config.json`. > **The EP model is the canon, not an add-on.** Axioms, frameworks, the belief graph, > heuristics, traces — there is no separate `cognitive-model.md`; they are EP relations, > queried by the contour and rendered on demand. Append-only refinement pipeline + format: > **`reference/07-ep-store.md`**. ### Phase 4b — PLAYBOOK (procedural methodology, when the author teaches one) Load **`reference/05-playbook.md`**. If the corpus contains how-to / instructional content, capture the author's **concrete methodology** as `kind:"procedure"` EP points: ordered steps, tactics, checklists, numbers/thresholds, recommended tools, verbatim scripts/templates, and "don't do this" mistakes — each grounded by its `text` + deep-link. This is *what to do* (vs Phase 4's *how the author thinks*). If the author is a pure thinker with **no** prescribed methodology, record "no methodology found" in coverage gaps. → `procedure`-kind `ep` rows; surfaced by `render playbook` (no stored file) ### Phase 4c — FAITHFULNESS CHECK (held-out smoke test) Load **`reference/06-evaluation.md`**. Hold out 5–10 EP points where the author states a clear, checkable position; for each, predict the answer *cold* through the contour and compare to the real `text`. Score match / partial / miss / **contradiction** (the dangerous one). This makes drift visible instead of trusting fluency — but it's a **smoke test, not proof** (small-N, gameable; never tune the model to pass it). Failing probes → fix the EP relations (tighten/remove the over-reached one), or lower confidence for thin domains. → a **faithfulness log** in `runs//` (probes, cold predictions, real text, verdicts), not stored prose ### Phase 5 — FINALIZE Write only **state** to `config.json` (chat_language, name variants, coverage-gap notes — the few facts not derivable from the corpus). Everything countable comes from `render manifest` (sources by type, EP counts by kind, source window) — don't store it. Give the user a build summary from `render manifest` + the faithfulness log (with its "indicative only" caveat), coverage gaps, and how to start chatting (the `intent` command). → writes `config.json` (state only); counts/contract come from `render manifest` --- ## CHAT mode Load **`reference/04-clone-runtime.md`**. The clone answers **only through the contour** (`scripts/loop.py`) — never reading the table or raw store directly. Run the cycle: `intent ""` → `sources` → `map ` → `select ` → `compile` (repeat map/select across the 1–3 sources that bear on the question) → read `runs//delivery.md` → write `runs//answer.md`, reasoning **as the author** over **only the delivered EPs** → `verify` (rejects any cited id not in the delivery — no id, no claim). Use `fts`/`get` for recall and `render brain` for the author's models. For the words shown to the user, live-ground the 1–3 backing sources (live fetch → `raw/` cache → the EP `text`). Three output contracts: - **How-to / "give me the steps" / "what's his method for X"** → `render playbook` + the procedure-kind EPs delivered: concrete steps, numbers, scripts, **cited verbatim with deep-links to the exact minute**. - **Advice / solve a task** → reason in the author's frameworks (`render brain`), ground in the delivered EPs, **cite the author verbatim with a deep-link to the exact minute**. - **Predict a position on a new topic** → map the topic to nearest EP relations, extrapolate along them, and **state confidence + which EPs drove the prediction**, clearly labeled as inference vs documented. --- ## Store & interface (per author, in the user's project) The canonical store is a **two-table SQLite database** (`clone.db`): `meta` (one row per source — provenance + integrity hash) and `ep` (the author's content as semantic **EP points**, group → vector → point; `text` = the grounded extract — the core — and `subject/relation/object` = the relation overlay for extrapolation). **Everything else is derived JIT and never stored** — the cognitive model, playbook, source table and the manifest are `render` views, not files. **The LLM never touches the DB or the shell directly. The only interface is the contour:** `scripts/loop.py`. Every read is a drill-down command; every write is a validated `import` that yields a log; representations come from `render`. See `ARCHITECTURE.md` for invariants and `reference/04-clone-runtime.md` for the cycle. ``` clones// clone.db CANONICAL — SQLite: meta + ep (+ ep_fts), CHECK/FK/NOT-NULL enforced. The one center. raw/.srt timecoded transcript (audio/video) — source material, referenced by meta.raw_path + hash raw/.md clean text per source — source material (books excepted) runs// per-intent contour artifacts: intent.md · selection.tsv · delivery.md · answer.md · log.jsonl config.json STATE only: chat_language, name variants (the few facts not derivable from the corpus) ``` Derived **on demand** by `loop.py render` (printed, never stored): the source table, the cognitive map (`render brain`), the playbook (`render playbook`), the contract (`render manifest`). Build / import / verify operations emit **logs**, not duplicate files. There is **no `evidence.jsonl`, no brain `.md`, no `manifest.json`** — those were copies of the canon. All paths are relative to the user's working directory, so the clone ships with their project. --- ## Guardrails - **No fabrication.** Every EP `text` in the `ep` table must be real and traceable to its source (`backing` + deep-link). Never invent citations. An answer may cite only EP ids delivered this run (`verify` enforces it). If you don't have an EP, say so. - **Label inference.** Documented view ≠ predicted view. Predictions must be marked and confidence-rated. - **Report gaps, never hide them.** If a source couldn't be transcribed or a topic isn't covered, state it. - **Public data only; this is a model, not the person.** See `reference/ethics.md`. - **Think, don't mimic.** The value is reproducing *reasoning*, not parroting catchphrases.