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:

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/<author-slug>/. 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 <slug> import <delta.jsonl> (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 <slug> 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/<id>.srt + raw/<id>.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 <slug> import <delta.jsonl> — 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/<id>.srt/raw/<id>.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 <year>. 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/<id>/ (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 "<question>" → sources → map <src> → select <src> <vectors> → compile (repeat map/select across the 1–3 sources that bear on the question) → read runs/<id>/delivery.md → write runs/<id>/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/<author-slug>/
  clone.db        CANONICAL — SQLite: meta + ep (+ ep_fts), CHECK/FK/NOT-NULL enforced. The one center.
  raw/<id>.srt    timecoded transcript (audio/video) — source material, referenced by meta.raw_path + hash
  raw/<id>.md     clean text per source — source material (books excepted)
  runs/<id>/      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.