Architect Your Manifesto

Introduction

30 Second Summary

Everyone collects fragments of their identity over time. Voice memos where you said something true. Decisions that revealed what you actually value. But without a system to organize it all, those fragments stay scattered and forgotten.

In this project, you will build a personal manifesto engine powered by four AI agent personas that transforms your voice recordings into a verified, multi-chapter account of who you are.

What You'll Build

A CI/CD pipeline for self-knowledge with parallel AI agents, adversarial quality gates, an interactive dashboard, and a queryable Obsidian vault.

By the end of this project, you'll have:

• A team of four expert AI agent personas (Ghostwriter, Interviewer, Counsel, Architect) that extract, verify, draft, and challenge your personal manifesto with 30+ years of domain expertise coded into each role.
• A full data pipeline flowing from raw voice recordings through staged transcripts, extracted claims, verified canon, and into polished manifesto chapters targeting 75,000 words over 6-12 months.
• An interactive HTML dashboard and Dataview-powered Obsidian vault showing your identity patterns, claim confidence, and chapter progress evolving over time.
• Secret Mission: A "Brand Voice" export that generates your positioning statement, elevator pitch, and LinkedIn summary from your verified identity.

Are there any prerequisites?

You need a Claude Max subscription (any tier), a Google account for the free Gemini API, and basic comfort with a terminal. No prior AI or Python experience is required.

Before We Start

Before We Start...

Set Up Your Foundation

Your manifesto engine needs a foundation of tools before it can start organizing your identity. You need a language runtime (Python), a way to talk to AI models (Claude Code and Gemini), a place to query your knowledge (Obsidian), and a project structure that supports a multi-stage data pipeline.

In this step, you will install everything and create the folder architecture that your four expert agents will operate within.

In this step, get ready to:

• Install Python, Node.js, and Claude Code CLI.
• Get your Gemini API key and set up Obsidian with the Dataview plugin.
• Create the project directory with the full pipeline folder structure, dependencies, and configuration files.

Install Python and Claude Code

The manifesto engine runs on Python for its pipeline logic and uses Claude Code as the AI orchestration layer. Claude Code requires Node.js to install.

• Check if Python 3.11 or higher is already installed by running this command:

python --version

✔️ I see version 3.11 or higher

Python is ready. Move on to the Node.js check below.

ⓧ I see an older version

Your system has an older Python version that will not work with this project's dependencies.

• Download the latest Python 3.11+ installer from python.org/downloads.
• Run the installer. On the first screen, check the box that says Add Python to PATH before clicking Install Now.
• Close and reopen your terminal, then run python --version again to confirm you see 3.11 or higher.

ⓧ Command not found

Python is not installed yet.

• Download the latest Python 3.11+ installer from python.org/downloads.
• Run the installer. On the first screen, check the box that says Add Python to PATH before clicking Install Now.
• Close and reopen your terminal, then run python --version again to confirm you see 3.11 or higher.

• Check if Node.js is installed by running this command:

node --version

✔️ I see a version number

Node.js is ready. Move on to installing Claude Code below.

ⓧ Command not found

Node.js is not installed yet.

• Download the LTS installer from nodejs.org.
• Run the installer with the default settings.
• Close and reopen your terminal, then run node --version again to confirm a version number appears.

• Install Claude Code globally by running this command:

npm install -g @anthropic-ai/claude-code

What is Claude Code?

Claude Code is an agentic AI coding tool that lives in your terminal. It can read your entire codebase, edit files, and run commands through natural language instructions.

In this project, you will use it to orchestrate parallel build agents that construct your manifesto pipeline simultaneously.

Install command not working?

If you see a permissions error, try running your terminal as Administrator. On Windows, right-click your terminal app and select Run as administrator.

If npm is not found, close and reopen your terminal after installing Node.js so it picks up the new PATH entries.

help me install Claude Code on Windows

• Authenticate Claude Code with your Max subscription by running:

claude

What happens during login?

On first launch, Claude Code opens a browser window where you sign in with your Claude.ai account. Follow the prompts to complete authentication.

If the browser does not open automatically, look for a URL in the terminal output and paste it into your browser manually. If you see a login code, paste it back into the terminal when prompted.

• Once logged in, exit the interactive session by typing exit or pressing Ctrl+D.
• Verify Claude Code works with your Max subscription by running:

claude -p "Say hello" --output-format json

What should I see?

You should see structured JSON output containing fields like type, result, session_id, and total_cost_usd.

The result field contains Claude's response. The total_cost_usd should show 0 because usage is included in your Max subscription.

Strip ANTHROPIC_API_KEY from your environment

If you have ANTHROPIC_API_KEY set as an environment variable, Claude Code routes through API billing instead of your subscription. Make sure this variable is unset so your Max plan is used.

Seeing an error or non-zero cost?

If you see a "command not found" error, close and reopen your terminal so it picks up the new PATH entries from the npm install.

If total_cost_usd is not 0, check whether ANTHROPIC_API_KEY is set in your shell environment. Remove it and try again.

help me troubleshoot my Claude Code installation

Get your Gemini API key and set up Obsidian

The Counsel agent in your pipeline runs on Gemini to maintain model-family independence from Claude. You also need Obsidian as the human-facing query layer for your knowledge vault.

• Open your browser and go to aistudio.google.com.
• Sign in with your Google account.
• Click Get API Key in the left sidebar.
• Click Create API key and select Create API key in new project.
• Copy the API key that appears. You will paste it into your config file shortly.

Why is Gemini free?

The Gemini 2.5 Flash free tier gives you 15 requests per minute and 1,500 requests per day with no credit card required. Your Counsel agent only runs once per weekly cycle, so the free tier is more than sufficient.

Can't create an API key?

If you see a permissions error, try creating a new project that is not associated with an organization. Personal Google accounts typically have no issues.

help me get a Gemini API key from Google AI Studio

Now set up your Obsidian vault for the manifesto pipeline.

• Press the Windows key to open your search bar.
• Type Obsidian and press Enter to open it.
• Click Create new vault.
• Name the vault manifesto and click Create.

What is Obsidian?

Obsidian is a local-first knowledge management tool that stores everything as Markdown files on your machine. Your pipeline writes claims, transcripts, and chapters as Markdown with YAML frontmatter.

Obsidian renders those files as an interactive, queryable knowledge graph with visual connections between notes.

• Install the Dataview community plugin by clicking the gear icon (Settings) in the bottom-left corner.
• Select Community plugins in the left sidebar.
• If prompted, click Turn on community plugins to enable the feature.
• Click Browse.
• Search for Dataview and click Install.
• After installation completes, click Enable.

What is Dataview?

Dataview is an Obsidian plugin that indexes all YAML frontmatter fields in your vault. It lets you write live queries (like SQL for your notes) that display as tables, lists, or calendars.

Your pipeline uses Dataview to make claims, transcripts, and chapters searchable and sortable by confidence, type, sensitivity, and date.

Create the project and initialize git

Your manifesto engine uses a multi-stage folder structure inspired by CI/CD data pipelines. Each folder represents a stage in the journey from raw recording to verified manifesto chapter.

• Open your terminal. Press the Windows key, type PowerShell, and press Enter.
• Move to your Desktop by running this command:

cd ~/Desktop

• Create your project folder and move into it by running these commands:

mkdir manifesto-engine
cd manifesto-engine

• Initialize a git repository by running:

git init

Git not found?

If git is not recognized, download and install Git from git-scm.com. Use the default installer settings. Close and reopen your terminal after installation.

help me install Git on Windows

• Create the full pipeline folder structure by running:

mkdir data/00-raw, data/01-staged, data/02-ingested, data/03-manifesto/chapters, data/03-manifesto/revision-history, data/interview-queue, output, output/identity-history, output/weekly, backups, docs/adr, docs/personas, .claude/agents

What do these folders represent?

• data/00-raw/ holds your voice memos and transcripts before any processing.
• data/01-staged/ holds normalized transcripts with Dataview-compatible frontmatter.
• data/02-ingested/ holds extracted, verified claims linked back to sources.
• data/03-manifesto/ holds chapter drafts and their revision histories.
• docs/personas/ holds your four expert agent persona definitions.
• .claude/agents/ holds Claude Code agent definition files for parallel builds.

• Confirm the folders exist by running:

ls

You should see backups, data, docs, and output listed in the output.

The .claude folder may be hidden

Folders starting with a dot are hidden by default in file explorers. The .claude/agents/ folder is there even if you do not see it in File Explorer. Run ls .claude to verify.

• Install the Python dependencies by running:

pip install faster-whisper google-generativeai pydantic pyyaml

What do these packages do?

• faster-whisper transcribes your voice memos locally on your GPU.
• google-generativeai provides the Python SDK for calling Gemini (used by the Counsel agent).
• pydantic handles data validation for claims, chapters, and identity models.
• pyyaml reads and writes YAML configuration and frontmatter files.

Pip install failing?

If you see a "pip not found" error, try pip3 instead of pip. On some Windows setups, the Python installer creates pip3 as the default command.

If you see build errors related to faster-whisper and CUDA, the package will still install. GPU acceleration is configured when you first run transcription.

help me install the Python dependencies for my manifesto engine

• Create the config.yaml file. Open your manifesto-engine folder in a text editor, create a new file called config.yaml, and paste the following:

# Manifesto Engine Configuration

gemini:
  api_key: "your-api-key-here"

backup:
  path: "[[BACKUP_PATH="C:/Users/YourName/OneDrive/manifesto-backups"]]"

What does this configure?

The gemini.api_key field holds the API key you copied from Google AI Studio. Replace the placeholder with your actual key.

The backup.path tells the weekly pipeline where to save backup copies of your data. Choose a location like a OneDrive folder, external drive, or a second disk path.

• Create the CLAUDE.md system context file. In the same folder, create a new file called CLAUDE.md and paste the following:

# Manifesto Engine

## Project Purpose
A personal manifesto generation system with four expert agent personas
(Ghostwriter, Interviewer, Counsel, Architect) that transforms voice memos
into a verified multi-chapter manifesto.

## Directory Structure
- data/00-raw/ - Raw input files (transcripts, audio)
- data/01-staged/ - Normalized transcripts with frontmatter
- data/02-ingested/ - Extracted and verified claims
- data/03-manifesto/chapters/ - Manifesto chapter drafts
- data/03-manifesto/revision-history/ - Revision feedback history
- data/interview-queue/ - Pending clarifying questions
- output/ - Generated reports and dashboards
- output/identity-history/ - Timestamped identity snapshots
- output/weekly/ - Weekly run outputs
- backups/ - Automated pipeline backups
- docs/adr/ - Architecture Decision Records
- docs/personas/ - Agent persona specifications
- .claude/agents/ - Claude Code agent definitions

## Conventions
- All Markdown files include YAML frontmatter for Obsidian Dataview
- Claims use wikilinks to reference source transcripts
- Sensitivity levels: manifesto-safe, private
- Pipeline stages: raw > staged > ingested > canon > manifesto
- Counsel runs on Gemini (model-family independence)
- Voice guide and structure preferences stored in YAML at project root

What is CLAUDE.md?

When Claude Code starts a session in your project, it reads CLAUDE.md as system context. This file tells Claude about your project structure, conventions, and terminology so every agent session starts with full awareness of how the pipeline works.

• Save both files in the root of your manifesto-engine folder.

✔️ Awesome, I've got everything!

Double check that you saved both config.yaml and CLAUDE.md in the root of your manifesto-engine folder (not inside a subfolder).

ⓧ I'd like to double check the full code

Here is config.yaml:

# Manifesto Engine Configuration

gemini:
  api_key: "your-api-key-here"

backup:
  path: "[[BACKUP_PATH="C:/Users/YourName/OneDrive/manifesto-backups"]]"

Here is CLAUDE.md:

# Manifesto Engine

## Project Purpose
A personal manifesto generation system with four expert agent personas
(Ghostwriter, Interviewer, Counsel, Architect) that transforms voice memos
into a verified multi-chapter manifesto.

## Directory Structure
- data/00-raw/ - Raw input files (transcripts, audio)
- data/01-staged/ - Normalized transcripts with frontmatter
- data/02-ingested/ - Extracted and verified claims
- data/03-manifesto/chapters/ - Manifesto chapter drafts
- data/03-manifesto/revision-history/ - Revision feedback history
- data/interview-queue/ - Pending clarifying questions
- output/ - Generated reports and dashboards
- output/identity-history/ - Timestamped identity snapshots
- output/weekly/ - Weekly run outputs
- backups/ - Automated pipeline backups
- docs/adr/ - Architecture Decision Records
- docs/personas/ - Agent persona specifications
- .claude/agents/ - Claude Code agent definitions

## Conventions
- All Markdown files include YAML frontmatter for Obsidian Dataview
- Claims use wikilinks to reference source transcripts
- Sensitivity levels: manifesto-safe, private
- Pipeline stages: raw > staged > ingested > canon > manifesto
- Counsel runs on Gemini (model-family independence)
- Voice guide and structure preferences stored in YAML at project root

Your foundation is complete. You have Python, Claude Code, Gemini access, an Obsidian vault, and a full pipeline folder structure ready to go. Next up, you will architect the system by generating ADRs and Mermaid diagrams that document every design decision before writing a single line of pipeline code.

Architect the System

Your foundation is solid. You have Python, Claude Code, a Gemini key, and an empty project structure waiting to be filled. Now comes the part most people skip and later regret: designing the system before building it.

Before a single line of pipeline code gets written, you need to document WHY this system is built the way it is. Architecture Decision Records capture each design choice and its trade-offs. Mermaid diagrams make the data flow visible. And the adversarial Counsel prompt gets authored independently so your quality gates have real teeth.

In this step, get ready to:

• Generate six Architecture Decision Records documenting every major design choice.
• Create system diagrams using Mermaid that render natively in Obsidian.
• Author the adversarial Counsel prompt independently from the build agents.

Generate the Architecture Decision Records

An ADR captures a single architectural decision: the context that made it necessary, what was chosen, and what trade-offs that creates. Six decisions define this system's shape.

• Open Claude Code in interactive mode by running this command from your project root:

claude

What is interactive mode?

Running claude without any flags opens a terminal-based chat session. You type prompts, Claude Code reads your project files, and it can create or edit files directly. You approve each file operation as it asks.

• Once Claude Code is running, paste the following prompt to generate all six ADRs:

Generate 6 Architecture Decision Records in docs/adr/ using the standard ADR format (Title, Status: Accepted, Context, Decision, Consequences). Create these files:

1. 001-indexing-strategy.md - Why SQLite FTS5 + Obsidian Dataview over LlamaIndex or vector databases. Context: personal corpus growing at 10-30 claims per week won't exceed a few thousand documents for years. FTS5 provides BM25-ranked full-text search with zero dependencies. Vector similarity is unnecessary at this scale.

2. 002-llm-routing.md - Why Claude via subprocess + Gemini free tier over API keys or local models. Context: Claude Code runs on Max subscription (no API cost). Gemini free tier provides model-family independence for adversarial review at zero cost.

3. 003-pipeline-stages.md - Why raw/staged/ingested/canon/manifesto stages over a flat structure. Context: each stage has a quality gate. Data promotes forward only when it meets the gate criteria. Failed items stay in their current stage.

4. 004-obsidian-integration.md - Why Dataview frontmatter + wikilinks over a custom UI. Context: Obsidian renders Markdown natively, Dataview indexes YAML frontmatter for live queries, wikilinks create a knowledge graph visible in graph view.

5. 005-vault-schema.md - Define frontmatter fields (source, date, word_count, stage, claim_type, confidence, epistemic_label, sensitivity), tag taxonomy (#stage/raw, #stage/staged, #stage/ingested, #stage/canon, #type/belief, #type/value, #type/decision, #type/experience, #type/aspiration, #epistemic/certain, #epistemic/likely, #epistemic/speculative, #epistemic/contradicted), wikilink conventions, sensitivity classification (manifesto-safe, private), and Dataview query templates.

6. 006-agent-personas.md - Define four runtime personas (Ghostwriter, Interviewer, Counsel, Architect) with their expertise, job descriptions, memory systems, and the adversarial independence requirement for Counsel (different model family, prompt authored separately, never modifiable by build agents).

Each ADR should be thorough (200-400 words per file). Use Markdown formatting that renders cleanly in Obsidian.

What do these ADRs capture?

Each ADR answers a single question about why the system is designed a specific way:

• 001-indexing-strategy.md explains why SQLite FTS5 beats vector databases at this scale.
• 002-llm-routing.md documents the dual-model strategy (Claude for generation, Gemini for adversarial review).
• 003-pipeline-stages.md justifies the five-stage promotion pipeline with quality gates.
• 004-obsidian-integration.md explains why a queryable vault replaces a custom dashboard UI.
• 005-vault-schema.md defines the exact frontmatter fields, tags, and query templates every file will use.
• 006-agent-personas.md specifies the four expert personas and their adversarial independence rules.

• Approve the file creation operations as Claude Code asks permission for each one.
• Once Claude Code finishes, verify the ADR files were created by running this in a separate terminal:

ls docs/adr/

You should see six files: 001-indexing-strategy.md through 006-agent-personas.md.

Don't see all six files?

Claude Code sometimes splits generation across multiple responses. If you see fewer than six files, tell it: "Please generate the remaining ADRs" and it will pick up where it left off.

If Claude Code exited unexpectedly, run claude again and ask it to check which ADRs are missing from docs/adr/ and generate the rest.

help me debug why Claude Code didn't generate all six ADR files

• Open one of the ADR files to confirm it has the correct structure. Run:

cat docs/adr/001-indexing-strategy.md

You should see a Markdown file with clear sections for Context, Decision, Consequences, and Status (Accepted).

Generate the system diagrams

Diagrams make the system's data flow visible at a glance. Obsidian renders Mermaid code blocks natively without any extra plugins, so your diagrams live right alongside your documentation.

• In your Claude Code session (or start a new one with claude), paste the following prompt to generate the architecture diagrams:

Create docs/architecture.md containing five Mermaid diagrams. Each diagram should be in a fenced code block with the mermaid language tag so Obsidian renders them natively.

1. Full Pipeline Flowchart - A flowchart showing the complete data flow: Recording input → 00-raw/ → transcription → 01-staged/ → claim extraction (Interviewer) → 02-ingested/ → interview verification → canon promotion → 03-manifesto/chapters/ (Ghostwriter drafts). Include error/retry paths: if any step fails, it logs the failure and the item stays in its current stage for retry on next run.

2. Interview Agent Loop (sequence diagram) - Show the interaction: Interviewer reads staged transcript → extracts claims with confidence scores → claims above 0.7 auto-promote → claims below 0.7 generate clarifying questions → questions go to interview-queue/pending.md → user answers → re-extraction → promote to ingested.

3. Ghostwriter Revision Loop (sequence diagram) - Show: Ghostwriter reads canon claims + voice-guide → drafts chapter → self-revision pass (voice fidelity, pacing, arc) → shows draft to user → user marks keep/rework/cut → Ghostwriter revises → stores feedback in revision-history → Counsel review → final approval.

4. Entity-Relationship Diagram - Show how these entities connect: Transcripts, Claims, Chapters, Personas, Identity Versions, Sensitivity Levels. Transcripts contain many Claims. Claims feed into Chapters. Personas operate on Claims and Chapters. Identity Versions snapshot the full state. Sensitivity Levels classify Claims as manifesto-safe or private.

5. Backup and Versioning Strategy - Show: before each weekly run, data/ and output/ are copied to backup location → pipeline runs → on success, identity.yaml gets a new timestamped version in output/identity-history/ → dashboard regenerates.

Add a brief heading and one-sentence description above each diagram explaining what it shows.

Why five diagrams?

Each diagram answers a different architectural question. The pipeline flowchart shows the overall data journey. The sequence diagrams zoom into two critical loops (interview and revision). The ER diagram shows how data entities relate. The backup diagram shows how your work stays safe.

All five render directly in Obsidian when you open docs/architecture.md in reading view. No extra plugins required.

• Approve the file creation when Claude Code asks.
• Verify the file was created by running:

ls docs/architecture.md

• Open your Obsidian vault.
• Navigate to docs/architecture.md in the file explorer sidebar.
• Switch to reading view by clicking the book icon in the top right corner (or pressing Cmd+E on macOS or Ctrl+E on Windows).

You should see all five Mermaid diagrams rendered as visual flowcharts, sequence diagrams, and entity-relationship diagrams. The pipeline flowchart should show your data flowing from raw recordings through to manifesto chapters.

Diagrams showing as raw text?

Make sure you are in reading view, not editing view. Mermaid diagrams only render in reading view in Obsidian.

If diagrams still show as text, check that each code block uses the mermaid language tag (not text or blank). Ask Claude Code to fix any blocks that are missing the language tag.

help me fix my Mermaid diagrams that aren't rendering in Obsidian

Author the adversarial Counsel prompt independently

This step matters more than it looks. In Step 4, three build agents will construct the pipeline. If one of those agents also wrote the Counsel's review criteria, the quality gate would be compromised. A reviewer who defines their own standards will always pass their own test.

Why author this prompt separately?

The Counsel persona is your adversarial quality gate. It runs on a different AI model family (Gemini instead of Claude) and uses a prompt that no other agent can modify. This creates genuine independence.

If the same model that writes drafts also writes the review criteria, you get a rubber stamp, not a real editor. The Counsel prompt is authored now, reviewed by you, and locked before any build agent touches it.

• In your Claude Code session, paste the following prompt to generate the Counsel's system prompt:

Create docs/personas/counsel-prompt.md containing a system prompt for an adversarial Counsel agent. This prompt will be loaded at runtime by the Gemini API, NOT by Claude. The Ghostwriter and Interviewer agents must never have write access to this file.

The Counsel persona is:
- A senior editor and fact-checker with 30+ years of experience
- Runs on Gemini 2.5 Flash (model-family independence from Claude)
- Tone: rigorous, fair, direct. Not hostile. Challenges without attacking.

The system prompt should instruct the Counsel to:
1. Read approved manifesto chapters, identity profile, and canon claims
2. Find contradictions the Ghostwriter missed (claims that conflict across chapters)
3. Flag self-deception (stated beliefs vs. evidence from decisions/actions)
4. Identify narrative gaps where chapters lack supporting evidence
5. Verify no unsupported claims made it into the manifesto text
6. Challenge overall coherence across the full chapter structure
7. Check whether previous cycle's findings were addressed or are still present
8. Rate each finding as HIGH (blocks promotion), MEDIUM (flag for review), or LOW (noted only)
9. Produce a structured counsel_report.md with severity ratings

IMPORTANT: The prompt must explicitly state that the Counsel does NOT:
- Rewrite or suggest alternative text (that is the Ghostwriter's job)
- Ask the user questions (that is the Interviewer's job)
- Reorganize chapters (that is the Architect's job)
- Access or modify other persona prompts

Format the file with a clear header explaining its purpose and independence requirement, followed by the full system prompt in a code block that can be loaded programmatically.

What does this prompt do at runtime?

When the pipeline runs its quality gate step, it loads this file and sends it to Gemini 2.5 Flash as a system prompt along with your manifesto chapters. Gemini evaluates the chapters against the criteria you just defined and produces a structured report with severity ratings.

HIGH severity findings (genuine contradictions, unsupported claims) trigger new interview questions. MEDIUM findings get flagged for your review. LOW findings are simply noted.

• Approve the file creation when Claude Code asks.
• Now review the generated prompt yourself. Open the file by running:

cat docs/personas/counsel-prompt.md

• Read through the system prompt. Confirm it includes all nine evaluation criteria (contradictions, self-deception, gaps, unsupported claims, coherence, previous findings, severity ratings, structured output, scope boundaries).
• If anything feels too lenient or is missing a criterion, edit the file directly or ask Claude Code to strengthen it. This is your chance to define how hard the Counsel pushes back.

Make the Counsel tougher, not nicer

The temptation is to soften the Counsel's criteria so your chapters pass more easily. Resist it. A manifesto that survives adversarial review is one you can actually stand behind. The discomfort is the feature.

• Verify all your architecture artifacts are in place by running:

ls docs/adr/ docs/personas/ docs/architecture.md

You should see six ADR files in docs/adr/, counsel-prompt.md in docs/personas/, and docs/architecture.md listed.

Missing the counsel-prompt.md file?

Make sure the file landed in docs/personas/ and not in the project root or another folder. If Claude Code placed it in the wrong location, move it with:

mv counsel-prompt.md docs/personas/counsel-prompt.md

help me find where my counsel-prompt.md file ended up

Your system architecture is fully documented. Six ADRs explain every design decision. Five Mermaid diagrams visualize the data flow. And your adversarial Counsel has its marching orders, locked and independent. Next up, you will define the full agent team that brings this architecture to life.

Define Your Agent Team

Your architecture is in place. ADRs document every design decision. Mermaid diagrams visualize the full pipeline. The adversarial Counsel prompt sits independently authored and locked down.

Now you need the team that actually operates this pipeline. Four expert agent personas, each with decades of domain expertise coded into their system prompts, will power every stage of your manifesto engine. In this step, you will define who they are, what they do, and how they interact with your material.

In this step, get ready to:

• Write the Ghostwriter persona specification with publishing expertise, voice fidelity, and sensitivity rules.
• Write the Interviewer, Counsel, and Architect persona specifications.
• Run the onboarding interview to establish your tone, audience, structure, and privacy boundaries.

Write the Ghostwriter persona

The Ghostwriter is the persona responsible for every word that enters your manifesto. It drafts chapters from verified canon claims, checks every paragraph against your voice preferences, and performs self-revision before showing you anything.

A detailed persona specification ensures consistent behavior across 75,000 words and 12 chapters. Without it, each Claude call would start from scratch with no memory of your tone or boundaries.

• In your Claude Code interactive session (run claude in your project root if you are not already in one), ask it to create the Ghostwriter persona file:

Create docs/personas/ghostwriter.md with a full persona specification for the Ghostwriter agent.

Requirements:
- 30+ years of publishing expertise in long-form narrative nonfiction, memoir, and personal essay
- Job description: drafts manifesto chapters from verified canon claims, maintains voice consistency across 75,000 words (12 chapters at ~6,250 words each)
- Self-revision: performs a revision pass before showing drafts to the user
- Voice fidelity: checks every paragraph against voice-guide.yaml
- Sensitivity: only draws from manifesto-safe claims for chapter text, uses private claims for thematic understanding only
- Tone: warm, precise, literary but accessible
- Skills: pacing, narrative arc, chapter transitions
- Memory: stores all revision feedback in data/03-manifesto/revision-history/ and references it for future chapters
- Progress tracking: reports per-chapter word count against 6,250 target

What does this persona specification do?

The persona file becomes the system prompt injected into every Claude call related to chapter drafting. Each section translates directly into agent behavior:

• The expertise section gives Claude the right framing for long-form writing decisions.
• The sensitivity rules prevent private claims from leaking into manifesto text.
• The memory section tells the agent where to store and retrieve revision feedback so it improves over time.
• The progress tracking section enables the agent to report how close each chapter is to its 6,250-word target.

• After Claude Code generates the file, verify it exists by running:

cat docs/personas/ghostwriter.md

You should see a structured Markdown file with sections covering expertise, job description, tone, sensitivity rules, memory system, and progress tracking.

Refine if needed

If any section feels off, tell Claude Code directly what to change. For example: "Make the tone section more specific about avoiding academic language" or "Add a rule about never using passive voice in chapter drafts." The persona is yours to shape.

Write the Interviewer, Counsel, and Architect personas

Three more agents round out your team. Each has a distinct role in the pipeline, and their persona files define how they behave when called.

• In your Claude Code session, ask it to create the Interviewer persona:

Create docs/personas/interviewer.md with a full persona specification for the Interviewer agent.

Requirements:
- Senior journalist meets therapist, 30+ years of experience
- Warm, curious, non-leading questioning style
- Specializes in surfacing beliefs people did not know they held
- References ALL previous claims and contradictions when formulating questions
- Asks about sensitivity classification for personal material
- Never uses leading questions like "Did you mean X?" - instead references specific timestamps and asks open clarifying questions

Why non-leading questions matter

A leading question like "Did you mean you value honesty?" creates a false positive. The person agrees because it sounds right, not because it is right. The Interviewer instead references specific moments: "In minute 3:12 you said X, and in minute 8:51 you said Y. Same situation or two different ones?"

This approach surfaces genuine beliefs rather than confirming assumptions.

• Next, ask Claude Code to create the Counsel persona:

Create docs/personas/counsel.md with a full persona specification for the Counsel agent.

Requirements:
- Senior editor and fact-checker, 30+ years of experience
- Runs on Gemini for model-family independence (not Claude)
- Uses the independently-authored prompt from docs/personas/counsel-prompt.md
- Catches self-deception and thin evidence
- References previous counsel reports to avoid repeating findings
- Checks for contradictions the Ghostwriter missed
- Identifies narrative gaps where chapters lack evidence
- Severity ratings: HIGH (contradictions, unsupported claims), MEDIUM (flagged for review), LOW (noted only)

Why does Counsel run on a different model?

If the same model that writes the draft also reviews it, the review is compromised. Claude wrote the chapters. Gemini reviews them. The Counsel prompt was authored independently in Step 2 and is never accessible to the Ghostwriter or Interviewer build agents.

This creates genuine adversarial independence. The Counsel has no incentive to agree with the Ghostwriter's choices.

• Finally, ask Claude Code to create the Architect persona:

Create docs/personas/architect.md with a full persona specification for the Architect agent.

Requirements:
- Senior narrative designer, 30+ years of experience
- Organizes 75,000 words into a coherent multi-chapter structure
- Finds story arcs in raw evidence
- Proposes but never overwrites (suggestions only, user approves)
- Tracks chapter growth rates and estimates completion timeline
- Identifies chapter boundaries from canon claims
- Watches chapter-level coherence across the full manifesto

• Verify all four persona files exist by running:

ls docs/personas/

You should see five files: architect.md, counsel-prompt.md, counsel.md, ghostwriter.md, and interviewer.md.

Missing a persona file?

If ls shows fewer than five files, check that Claude Code created each file in the correct directory. You can ask Claude Code: "Check if docs/personas/ has all four persona files plus the counsel-prompt." It will identify and fix any missing files.

help me check why a persona file is missing from docs/personas/

Run the onboarding interview

Your four agents now have expertise and job descriptions. But the Ghostwriter cannot draft in your voice without knowing what your voice sounds like. The onboarding interview captures your preferences before any chapter is written.

The Ghostwriter persona asks you direct questions about tone, audience, structure, and privacy. Your answers become the reference files it checks against on every single draft.

• Run the onboarding interview by executing this command in your terminal:

python -m manifesto onboard

What questions will the onboarding ask?

The Ghostwriter persona asks six categories of questions:

• Tone: conversational, literary, direct, or reflective?
• Audience: personal, family, public, or professional network?
• Structure: chronological, thematic, or transformation-based?
• Voice patterns: what speech habits should the system preserve?
• Private topics: recorded in claims but never surfaced in manifesto text.
• Off-limits topics: not even recorded at all.

• Answer each question honestly. There are no wrong answers.
• If you freeze on the tone question ("I don't know my tone"), the system offers examples from your first transcript to help you identify patterns. If you have no transcripts yet, pick the option that feels closest and refine later.

You can re-run onboarding anytime

Your preferences will evolve as you use the system. Run python -m manifesto onboard again in the future to update your voice guide, structure preferences, or privacy boundaries. The Ghostwriter adapts to whatever is current in the YAML files.

• After completing the interview, verify that the three preference files were created:

ls voice-guide.yaml structure-preferences.yaml sensitivity-rules.yaml

You should see all three files listed. These live in your project root and are referenced by the Ghostwriter on every chapter draft.

• Open voice-guide.yaml to confirm your tone preferences are captured:

cat voice-guide.yaml

You should see your documented tone, voice patterns to preserve, and stylistic guidelines. This is the reference the Ghostwriter checks against on every paragraph it writes.

Files not created after onboarding?

If ls does not show the three YAML files, the onboarding command may have exited early. Check your terminal output for error messages. Common causes:

• You pressed Ctrl+C during the interview, which cancelled before saving.
• A missing Python dependency prevented the module from loading. Run pip install pyyaml and try again.

help me debug why python -m manifesto onboard did not create my YAML preference files

Your agent team is defined and your preferences are locked in. Next up, you will put these personas to work by building the entire pipeline infrastructure with three parallel Claude Code agents running simultaneously.

Build the Infrastructure with Parallel Agents

Your agent team is fully defined. Four expert personas with detailed job descriptions, memory systems, and professional standards. The architecture is documented with ADRs and Mermaid diagrams. Now it is time to turn all of that design into working code.

In this step, you will write instructions for three Claude Code build agents, launch them in parallel, and merge their output into a unified Python module. Each agent builds its component in an isolated Git worktree so they never conflict with each other.

In this step, get ready to:

• Write three build agent definition files that instruct Claude Code what to build.
• Launch all three agents in parallel using isolated git worktrees.
• Merge the branches and verify the complete pipeline works end-to-end.

Write the three build agent definition files

Claude Code supports custom agents defined as Markdown files in the .claude/agents/ directory. Each file becomes a set of instructions that Claude Code follows when launched with the --agent flag.

• Create the first agent definition file by creating .claude/agents/pipeline-architect.md with the following content:

# Pipeline Architect (Agent A)

You are building the storage and infrastructure layer for a personal manifesto engine.

## Your Responsibilities

Build these components as a Python package called `manifesto/`:

### Storage Layer
- SQLite database with FTS5 full-text search indexing
- Content table pattern (avoids data duplication)
- BM25-ranked search queries
- Triggers to keep FTS index in sync with content changes

### Pipeline Stage Promotion
- Stage enum: raw, staged, ingested, canon, manifesto
- Promotion logic with validation gates between stages
- Import/export utilities for each stage

### Obsidian Markdown Writer
- Generate Markdown files with Dataview-compatible YAML frontmatter
- Include typed fields: dates as ISO8601, numbers as bare values, lists as arrays
- Add wikilinks between related notes (claims link to transcripts, chapters link to claims)
- Apply sensitivity tags from sensitivity-rules.yaml
- Tag taxonomy: #stage/raw, #stage/staged, #stage/ingested, #stage/canon
- Type tags: #type/belief, #type/value, #type/decision, #type/experience, #type/aspiration

### Persona Loader
- Read persona Markdown files from docs/personas/
- Inject expert system prompts into every Claude subprocess call
- Strip ANTHROPIC_API_KEY from subprocess environment (forces Max subscription routing)
- Load config.yaml for runtime settings

### Backup System
- Copy data/ and output/ to the configured backup location before each weekly run
- Timestamped backup folders
- Verify backup path is writable on startup

### Retry and Graceful Degradation
- Wrap each pipeline step in try/except
- On failure: log the error, skip that step, flag it for next run
- Never corrupt existing data on failure
- Save progress between steps so interrupted runs resume cleanly

## Conventions
- Use Python 3.11+ features
- Use pydantic for data validation
- Use pyyaml for config loading
- All files go in the manifesto/ package directory
- Include __main__.py for `python -m manifesto` CLI entry point
- Add a `status` subcommand that reports component health
- Add a `pipeline-check` subcommand that verifies end-to-end connections
- Add a `persona-check` subcommand that verifies all persona files load
- Add a `backup-check` subcommand that confirms backup path is writable

What does this file do?

This Markdown file is an instruction document for Claude Code. When you launch Claude Code with --agent pipeline-architect, it reads this file as its system context and builds everything described here.

The persona loader strips ANTHROPIC_API_KEY from the subprocess environment. This forces Claude Code to route through your Max subscription instead of API billing.

• Create the second agent definition file by creating .claude/agents/intelligence-engine.md with the following content:

# Intelligence Engine (Agent B)

You are building the claim extraction and interview system for a personal manifesto engine.

## Your Responsibilities

Build these components in the `manifesto/` Python package:

### Claim Extraction
- Read staged transcripts and extract atomic claims using the Interviewer persona
- Each claim gets: text, type (belief/value/decision/experience/aspiration), epistemic label (certain/likely/speculative/contradicted), confidence score (0-1), sensitivity classification (manifesto-safe/private), source reference linking to original transcript
- Use Claude via subprocess with the Interviewer persona system prompt injected
- Reference ALL previous claims when extracting to catch contradictions and evolution

### Interview Agent
- Generate warm, non-leading clarifying questions for low-confidence claims
- Question format: reference specific timestamps and quotes, ask precise questions
- Store pending questions in data/interview-queue/pending.md
- Process resolved interviews and re-score affected claims
- Never ask "Did you mean X?" - always ask open-ended questions

### Confidence Scoring
- Claims scoring above 0.7 confidence auto-promote to ingested
- Claims below 0.7 trigger clarifying questions
- Score based on: specificity, consistency with other claims, presence of concrete evidence

### Sensitivity Classification
- Apply rules from sensitivity-rules.yaml
- Two levels: manifesto-safe (can appear verbatim in chapters) and private (informs themes but never quoted)
- Completely off-limits topics are never recorded at all

### Canon Promotion
- Move high-confidence ingested claims to canon status
- Canon claims are the only source material for manifesto chapters
- Track promotion history for provenance

### Onboarding Flow
- Ghostwriter persona asks tone, audience, structure, voice pattern, and privacy questions
- Generate voice-guide.yaml, structure-preferences.yaml, and sensitivity-rules.yaml
- If the user freezes, offer examples from their first transcript
- Register as `python -m manifesto onboard` subcommand

### Prompt Pack
- 15 recording prompts designed to surface identity material
- Examples: "Tell me about a time you quit something and it turned out to be the right call."
- "Describe a belief you held strongly 5 years ago that you no longer hold. What changed?"
- "What is a decision you made that nobody around you understood at the time?"
- Register as `python -m manifesto prompts` subcommand

## Conventions
- Use the storage layer and Obsidian writer from Agent A (import from manifesto package)
- All extracted claims become Markdown notes in data/02-ingested/ with proper frontmatter
- Handle Claude rate limits gracefully: save progress, report how many processed, suggest retrying later
- Register `extract` and `resolve-interviews` subcommands

Why does Agent B reference Agent A's code?

Agent B imports the storage layer and Obsidian writer that Agent A builds. This works because all three agents target the same manifesto/ package. After you merge the branches in order (A first, then B, then C), the imports resolve correctly.

• Create the third agent definition file by creating .claude/agents/manifesto-builder.md with the following content:

# Manifesto Builder (Agent C)

You are building the chapter generation, quality gates, and reporting system for a personal manifesto engine.

## Your Responsibilities

Build these components in the `manifesto/` Python package:

### Chapter Spine Generation
- Use the Architect persona to read all canon claims and identify chapter boundaries
- Generate a 12-chapter spine targeting 75,000 total words (~6,250 words per chapter)
- Report current word counts vs targets and estimate recordings needed for completion
- Register as part of `python -m manifesto build-chapters` subcommand

### Ghostwriter Chapter Drafting
- Load voice-guide.yaml, structure-preferences.yaml, and sensitivity-rules.yaml
- Draft chapters using ONLY manifesto-safe canon claims for verbatim text
- Private claims inform theme and structure but never appear as direct quotes
- Run self-revision pass before showing draft: voice fidelity, pacing, narrative arc
- Store drafts in data/03-manifesto/chapters/
- If voice fidelity fails repeatedly, suggest running `manifesto update-voice`

### Revision Loops
- Parse inline feedback markers: [KEEP], [REWORK: reason], [CUT: reason]
- Store all revision feedback in data/03-manifesto/revision-history/YYYY-MM-DD-chN.md
- Ghostwriter references revision history for future drafts (learns preferences)
- Architect watches cross-chapter coherence and flags contradictions
- Register as `python -m manifesto revise` subcommand

### Adversarial Counsel Integration
- Load the independently-authored counsel prompt from docs/personas/counsel-prompt.md
- Call Gemini 2.5 Flash via google-generativeai SDK (NOT Claude)
- Counsel reads approved chapters, identity profile, and canon claims
- Finds contradictions, self-deception, narrative gaps, unsupported claims
- References previous counsel reports to avoid repeating findings
- Produces output/counsel_report.md with severity ratings (HIGH/MEDIUM/LOW)
- Handle Gemini 429 errors: flag as skipped, do not block manifesto, retry next run
- Register as `python -m manifesto counsel` subcommand

### Identity Versioning
- Save timestamped identity snapshots to output/identity-history/YYYY-WW-identity.yaml
- Track theme evolution: which themes strengthened, which faded, when shifts happened
- Compare versions to detect identity drift over time

### Dashboard Generator
- Generate self-contained HTML file (dark theme, embedded CSS/JS, no external CDN)
- System prompt: "You are a senior product designer with 15+ years of experience in data visualization and dashboard design"
- Show: chapter completeness progress bars, theme heatmap, claim confidence distribution, pipeline stage funnel, identity drift over time, revision timeline, counsel finding trends
- Output to output/dashboard.html
- Register as `python -m manifesto dashboard` subcommand

### Report Writer
- Generate output/identity_report.md with: manifesto progress, pipeline health, identity profile, Twelve Favorite Problems, counsel findings, voice fidelity scores, State of the Self summary
- Register as `python -m manifesto report` subcommand

### Weekly Cycle Orchestrator
- Run full pipeline in sequence: backup > ingest > extract > promote > build-chapters > counsel > identity version > dashboard > report
- If any step fails: log error, skip step, continue with remaining steps
- Report which steps succeeded and which are pending retry
- Register as `python -m manifesto weekly` subcommand
- Also register `python -m manifesto health` for retry-pending status

## Conventions
- Import storage layer, Obsidian writer, and persona loader from Agent A's code
- Import claim extraction and canon promotion from Agent B's code
- Use google-generativeai for all Gemini calls (model-family independence for Counsel)
- All subcommands registered in __main__.py CLI entry point

Why is the Counsel on Gemini instead of Claude?

The Counsel agent runs on a different AI model family (Gemini 2.5 Flash) to maintain adversarial independence. If the same model that writes the draft also reviews the draft, the review is compromised. Using Gemini ensures the quality gate is genuinely independent.

The Gemini free tier provides 15 requests per minute and 1,500 requests per day. This is more than enough for weekly counsel reviews.

• Save all three files in the .claude/agents/ directory.
• Confirm the files exist by running:

ls .claude/agents/

You should see pipeline-architect.md, intelligence-engine.md, and manifesto-builder.md listed.

Don't see all three files?

Make sure you created the files inside .claude/agents/ (note the leading dot on .claude). On Windows, some editors have trouble creating dot-prefixed folders. Use the terminal instead.

help me create files in a dot-prefixed directory on Windows

Launch all three build agents in parallel

Each agent runs in its own isolated git worktree. This means they each get a separate copy of your project files on a separate branch, so they can build simultaneously without overwriting each other's work.

• Open three separate terminal windows. You will run one agent in each.
• In Terminal 1, launch Agent A by running:

claude --worktree --agent pipeline-architect

• In Terminal 2, launch Agent B by running:

claude --worktree --agent intelligence-engine

• In Terminal 3, launch Agent C by running:

claude --worktree --agent manifesto-builder

What is happening in each terminal?

Each agent reads its definition file from .claude/agents/ and starts building the code described in it. The --worktree flag creates an isolated git worktree so each agent works on its own branch without conflicts.

Typical completion time is 8-12 minutes per agent. Since all three run simultaneously, the total wall-clock time is 8-12 minutes. Approve file operation permissions as each agent asks.

• Watch each terminal until the agent reports completion. If an agent errors, let it retry automatically. If it fails twice on the same task, note the issue for manual fixing after merge.

Agent stuck or erroring repeatedly?

If an agent fails more than twice on the same file, cancel it with Ctrl+C and note the error. You can fix the issue interactively after merging the other agents' work. The most common failure is a missing import or incorrect path reference.

help me debug a Claude Code agent that keeps failing on a specific file

Merge, integrate, and verify

Once all three agents finish, you bring their work together. Merge order matters because Agent B imports from Agent A's code, and Agent C imports from both.

• Back in your main terminal (not the agent terminals), merge the branches sequentially by running these commands:

git merge pipeline-architect
git merge intelligence-engine
git merge manifesto-builder

Why does merge order matter?

Agent A builds the foundation (storage, Obsidian writer, persona loader). Agent B depends on those imports. Agent C depends on both A and B. Merging in order (A, B, C) ensures each layer resolves its imports against the code that already exists in main.

• Verify all components initialized by running:

python -m manifesto status

• Confirm end-to-end pipeline connections by running:

python -m manifesto pipeline-check

• Verify all four expert personas load with their system prompts by running:

python -m manifesto persona-check

• Confirm the backup path is writable by running:

python -m manifesto backup-check

All four commands should report success. This confirms that the storage layer, pipeline stages, persona loading, and backup system are all connected and functional.

Seeing a check fail?

The most common failure after merging is a missing import or incorrect file path. Use Claude Code interactively to debug. Run claude in your project root and describe the error. Claude will read your codebase and fix the issue.

If persona-check fails, confirm that all four persona files exist in docs/personas/ (ghostwriter.md, interviewer.md, counsel.md, architect.md) and that docs/personas/counsel-prompt.md is present.

help me fix a failing manifesto check command after merging my build agents

Your entire pipeline infrastructure is now built and verified. Four expert personas are loaded, the storage layer is indexed, and the backup system is ready. Next up, you will bring your own voice into the system and watch the first stage of the pipeline come alive.

Bring Your Voice In

Your three parallel agents built the entire pipeline infrastructure in the previous step. All systems passed verification and the pipeline is operational.

Now the system needs something only you can provide: your actual voice. This step takes scattered recordings and transforms them into structured, searchable data for the first time.

In this step, get ready to:

• Choose your input path and add raw material to the pipeline.
• Run the ingest command to normalize and promote files to staged.
• Verify your staged transcripts appear in Obsidian with correct frontmatter.

Choose your input path and add your material

The pipeline accepts three types of input. Pick whichever fits your situation right now.

I have transcripts

If you already have text transcripts from Google Recorder, Otter, or any transcription tool, you can feed those directly into the pipeline.

• Copy your .txt or .md files into the data/00-raw/ folder inside your project directory.
• Each file should contain at least 100 words of content for the quality gate to pass.

Multiple files welcome

You can drop as many transcript files as you have. The ingest pipeline processes them all in one run.

I have audio files

If you have voice memos or recordings saved as audio files, the pipeline transcribes them locally on your GPU using faster-whisper.

• Drop your audio files (.mp3, .m4a, .wav) into data/00-raw/.
• Transcription runs at approximately 3-4x realtime using the large-v3-turbo model with INT8 quantization.
• The model uses about 2-3GB of VRAM on your RTX 2060 Super, leaving plenty of headroom.

What about other audio formats?

faster-whisper supports any audio format that ffmpeg handles. If you have .ogg, .flac, or .webm files, those work too.

I'm starting fresh

If you do not have existing recordings and feel stuck on what to say, the Prompt Pack helps. It contains 15 recording prompts designed to surface identity material.

• See the full Prompt Pack by running this command:

python -m manifesto prompts

Here are a few examples to get you thinking:

• "Tell me about a time you quit something and it turned out to be the right call."
• "Describe a belief you held strongly 5 years ago that you no longer hold. What changed?"
• "What is a decision you made that nobody around you understood at the time?"

• Pick one that resonates.
• Open your phone's voice recorder or any recording app.
• Talk for 5-10 minutes without editing yourself.
• Drop the resulting audio file into data/00-raw/.

Do not overthink this

The prompts are designed to bypass your inner editor. Rambling is fine. Contradictions are fine. The Interviewer agent in the next step sorts through everything.

Run the ingest pipeline

With raw material in the input folder, the ingest command detects file types, transcribes audio if needed, normalizes everything to Markdown with timestamps, and promotes files from 00-raw/ to 01-staged/.

• Run the ingest pipeline by executing this command:

python -m manifesto ingest

What does this command do?

The ingest pipeline performs several operations in sequence:

• Scans data/00-raw/ for new files and detects whether each is text or audio.
• Transcribes audio files using faster-whisper large-v3-turbo (INT8 on your GPU).
• Normalizes all content to Markdown with timestamps and consistent formatting.
• Applies the 100-word quality gate. Files below the threshold get flagged with an expansion suggestion instead of being promoted.
• Adds Dataview-compatible YAML frontmatter to each file (source, date, word_count, stage, tags).
• Promotes passing files from 00-raw/ to 01-staged/.

You should see terminal output listing each file processed, its word count, and whether it was promoted or flagged.

Pipeline says no files found?

• Confirm your files are inside data/00-raw/ and not in a subfolder within it.
• Check that your files have a recognized extension (.txt, .md, .mp3, .m4a, .wav).
• Make sure you are running the command from your project root directory.

If transcription is failing on audio files, verify that your GPU drivers are up to date and that no other application is consuming VRAM. Help me debug my manifesto ingest pipeline

What if I hit a rate limit?

If Claude rate-limits during any part of the pipeline, the system saves all progress and tells you how many files were processed. No work is lost. Run the command again tomorrow to continue where it left off.

Verify in Obsidian

Your staged transcripts now live as structured notes in your Obsidian vault. This is the first time your scattered thoughts exist as searchable, queryable data.

• Open your Obsidian vault.
• Navigate to the 01-staged/ folder in the file explorer sidebar.
• Click on any staged transcript file.

Each file should have YAML frontmatter at the top that looks like this:

---
source: my-recording.m4a
date: 2026-05-14
word_count: 847
stage: staged
tags:
  - stage/staged
---

What do these frontmatter fields mean?

• source links back to the original file in 00-raw/ so you always know where a transcript came from.
• date records when the file was ingested.
• word_count shows how much content the transcript contains.
• stage tracks where this file sits in the pipeline (staged means it passed the quality gate).
• tags makes the file filterable by Dataview queries.

• Open the vault index note in your vault root.

The pipeline created a Dataview TABLE query that displays all staged transcripts with their word counts and dates. It looks like this:

```dataview
TABLE source, date, word_count
FROM "01-staged"
SORT date DESC
```

You should see a live table listing every transcript that made it through the quality gate.

What about low-confidence transcriptions?

If faster-whisper produced garbled text or hallucinated segments during transcription, those sections are flagged with low-confidence markers in the transcript body. The extraction step in the next phase knows to treat these carefully and will not extract claims from flagged sections without verification.

Not seeing files in Obsidian?

• Confirm your Obsidian vault path matches the 01-staged/ output location. The pipeline writes directly to your vault's manifesto folder.
• Check that the Dataview community plugin is enabled in Settings > Community plugins.
• If the TABLE query shows "No results", verify that at least one file in 01-staged/ has the stage: staged frontmatter field.

My staged transcripts are not appearing in my Obsidian Dataview query

Your scattered voice memos now exist as structured, searchable data with provenance tracking. Next up, the Interviewer agent reads every transcript and extracts atomic claims about who you are.

Run the Interview Agent

Your transcripts are staged and visible in your vault. But raw transcripts are not usable material for a manifesto. They are messy, contradictory, and full of half-finished thoughts.

This step transforms that mess into structured, verified claims about who you are. The Interviewer persona reads every transcript, extracts atomic beliefs, and challenges anything ambiguous before it enters your knowledge base.

In this step, get ready to:

• Run the extraction pipeline to surface atomic claims from your staged transcripts.
• Review and answer clarifying interview questions for ambiguous claims.
• Explore your verified claims in Obsidian with a live Dataview query.

Run the extraction pipeline

The Interviewer persona is a senior journalist with 30+ years of experience surfacing beliefs people did not know they held. It reads each staged transcript and extracts individual claims with metadata.

• Start the extraction process by running this command in your project terminal:

python -m manifesto extract

What does this command do?

The Interviewer persona reads each file in data/01-staged/ via Claude Sonnet and extracts atomic claims. Each claim receives:

• A claim type (belief, value, decision, experience, or aspiration).
• An epistemic label (certain, likely, speculative, or contradicted).
• A confidence score from 0 to 1.
• A sensitivity classification (manifesto-safe or private).
• A source reference linking back to the original transcript.

Claims scoring above 0.7 confidence auto-promote to data/02-ingested/. Claims below 0.7 generate clarifying questions in data/interview-queue/pending.md.

• Wait for the extraction to complete. Depending on how many transcripts you staged, this may take a few minutes.
• Check your terminal output. You should see a summary reporting how many claims were extracted and how many were promoted versus queued for interview.

Seeing a usage limit message?

If Claude rate-limits during extraction, the system saves your progress automatically. You will see a message reporting how many transcripts were processed and that you can run again later to continue. No work is lost.

Run python -m manifesto extract again the next day to pick up where it left off.

I hit a rate limit during extraction. How do I resume?

Review and resolve interview questions

Not every claim is clear-cut. When the Interviewer finds ambiguity or contradiction in your words, it generates warm, non-leading clarifying questions rather than guessing what you meant.

• Open data/interview-queue/pending.md in your editor or in Obsidian.

What do these questions look like?

The Interviewer does not ask leading questions like "Did you mean X?" Instead, it references specific timestamps and contradictions. For example: "In minute 3:12 you said 'closed late' and in minute 8:51 you said 'closed on time.' Same situation remembered differently, or two different situations? Which dates?"

These questions surface beliefs you did not know you held. That is the quality gate. Nothing enters your canon unverified.

• Read through the pending questions.
• Answer the ones that matter to you by typing your response directly below each question in the file.
• Skip any questions that feel irrelevant by leaving them unanswered.
• Save pending.md after you finish answering.
• Re-process your clarified claims by running this command:

python -m manifesto resolve-interviews

What happens after resolving?

Clarified claims promote to data/02-ingested/ with updated confidence scores. Claims you skipped remain in the queue for future consideration.

• Check your terminal output. You should see a confirmation that clarified claims were promoted to the ingested stage.

No questions appeared in pending.md?

If all your claims scored above 0.7 confidence, the Interviewer had nothing to ask. This means your recordings were clear and unambiguous. Your claims auto-promoted directly to data/02-ingested/.

No interview questions appeared. Is that normal?

Explore your claims in Obsidian

Each extracted claim is now a Markdown note in data/02-ingested/ with full YAML frontmatter and a wikilink back to its source transcript.

• Open your Obsidian vault.
• Navigate to the 02-ingested folder in the sidebar.
• Click on any claim note to see its frontmatter fields: type, confidence, epistemic_label, sensitivity, source_transcript, stage, and tags.

Now query your claims using Dataview. Create a new note (or use your vault index note) and paste this query inside a dataview code block:

```dataview
TABLE claim_type, confidence, sensitivity
FROM "02-ingested"
SORT confidence DESC
```

What does this query show?

This Dataview query renders a live table of every claim in your ingested folder, sorted by confidence from highest to lowest. You can see your beliefs ranked at a glance.

Notice which claims the system flagged as private in the sensitivity column. Those inform your identity profile but will never appear verbatim in the manifesto text.

• Verify the table renders in reading mode. You should see rows for each ingested claim with their type, confidence score, and sensitivity classification.

Dataview table not rendering?

Make sure you are viewing the note in reading mode (not editing mode). Dataview queries only render in reading mode or live preview.

Confirm the Dataview plugin is enabled: go to Settings then Community Plugins and check that Dataview is toggled on.

My Dataview query shows as plain text instead of a table. How do I fix this?

Your scattered thoughts are now structured, verified claims. Each one linked back to the exact moment you said it. Next, you will build these claims into actual manifesto chapters.

Build Your Manifesto

Your claims are verified. Every belief, value, and decision in data/02-ingested/ has been extracted, scored, and confirmed through the interview process. Now it is time to turn those verified fragments into something you can actually read.

In this step, two expert personas take the stage. The Architect reads all your verified claims and designs a 12-chapter structure targeting 75,000 total words. Then the Ghostwriter drafts each chapter using only your verified words, checking every paragraph against your documented voice before showing you anything.

In this step, get ready to:

• Promote high-confidence claims to canon and generate a 12-chapter spine.
• Have the Ghostwriter draft chapters with voice-fidelity verification.
• Review, revise, and approve your manifesto chapters.

Promote to canon and generate the chapter spine

Canon is the final stage before manifesto text. A claim that reaches canon status means you have verified it, clarified any ambiguity, and confirmed it represents something true about you.

The build-chapters command handles the full pipeline from canon promotion through chapter drafting. All claims above 0.7 confidence auto-promote to canon. Then the Architect persona reads every canon claim and identifies natural chapter boundaries.

• Run the chapter-building pipeline by executing this command:

python -m manifesto build-chapters

What does this command do?

This single command triggers three sequential operations. First, all ingested claims with confidence above 0.7 auto-promote to canon status. Second, the Architect persona reads all canon claims and generates a 12-chapter spine targeting 75,000 total words. Third, the Ghostwriter persona drafts each chapter.

The Architect reports per-chapter word counts against the 6,250-word target for each chapter. It also estimates how many more recordings you would need to reach first-draft completeness.

On your first run with 1-2 recordings, expect 3-4 skeleton chapters at 1,000-2,000 words each. You will see output like: "Chapter 1: 1,800/6,250 words. Chapter 2: 900/6,250 words. Estimated 8-10 more recordings across these topics would reach first-draft completeness."

Why so few words on the first run?

This is by design. The manifesto is a 6-12 month artifact that compounds weekly. Day 1 produces 1,000-2,000 words across skeleton chapters. Each week you add recordings, and each week the chapters grow. The system is built for compound growth, not instant completion.

No chapters generated?

Make sure you have claims in data/02-ingested/ with confidence scores above 0.7. If all your claims scored below 0.7, they would have triggered interview questions in the previous step. Check data/interview-queue/pending.md for unresolved questions.

help me debug why build-chapters produced no output

Understand how the Ghostwriter drafts chapters

The Ghostwriter does not simply concatenate your claims into paragraphs. It operates as a 30-year publishing veteran with specific constraints and quality checks.

What does the Ghostwriter do before showing you a draft?

• Reads voice-guide.yaml, structure-preferences.yaml, and sensitivity-rules.yaml to understand your preferences.
• Draws ONLY from manifesto-safe claims for verbatim text. Private claims inform theme and structure but never appear as quotes.
• Runs a self-revision pass before producing the draft: voice fidelity check against your documented tone, pacing check, and narrative arc check.
• Only after passing all three internal checks does the draft appear in data/03-manifesto/chapters/.

• Open your Obsidian vault and navigate to the data/03-manifesto/chapters/ folder.
• You should see 3-4 chapter files, each containing 1,000-2,000 words of drafted manifesto text.

Read through one of the chapter drafts. Does it sound like you? If not, that is exactly what the revision loop in the next substep is for.

What if the voice fidelity check fails repeatedly?

If the Ghostwriter cannot consistently match your documented tone, the system will ask whether your voice-guide needs updating. Your preferred tone may have shifted since onboarding. Run manifesto update-voice to re-calibrate if this happens.

Review, revise, and approve your chapters

The Ghostwriter's first draft is a starting point, not a final product. You control what stays, what gets reworked, and what gets cut. The revision loop teaches the Ghostwriter your preferences so future drafts get closer on the first attempt.

• Open each chapter file in your text editor or Obsidian.
• Read through the text and mark sections with inline comments using one of three labels:

• [REWORK: reason] for sections that need a different tone or approach. Example: [REWORK: too formal here].
• [CUT: reason] for sections that should be removed entirely. Example: [CUT: I never said this].
• Sections without a comment are treated as "keep" and remain unchanged.

• Save the chapter files with your inline comments.
• Run the revision pipeline by executing this command:

python -m manifesto revise

What does this command do?

The Ghostwriter reads your inline comments, incorporates the feedback, and produces a revised draft. Every piece of feedback is stored as permanent memory in data/03-manifesto/revision-history/YYYY-MM-DD-chN.md. The Ghostwriter references all previous revision history when drafting future chapters, so it learns your preferences over time.

The Architect persona also watches for cross-chapter coherence. If your revisions in Chapter 3 introduce something that contradicts Chapter 1, it flags the inconsistency for you to resolve.

• Read through the revised chapters. If you are happy with the result, move to the next substep.
• If a section still does not sound right, add new inline comments and run python -m manifesto revise again. Repeat until each chapter reads like you wrote it yourself.

The revision loop gets faster

Each round of feedback makes the Ghostwriter more attuned to your voice. By the third or fourth revision cycle, you will notice the drafts arriving much closer to what you want on the first pass. The system is learning your style from your corrections.

• Verify that revision history files now exist in data/03-manifesto/revision-history/. Each file is named with the format YYYY-MM-DD-chN.md and records what changed.

Chapters still don't sound like you after multiple revisions?

Check your voice-guide.yaml file. If the tone descriptions from onboarding no longer match how you want to sound, the Ghostwriter is targeting the wrong voice. Run python -m manifesto update-voice to update your voice profile with fresh examples from your latest recordings.

help me fix voice fidelity in my manifesto chapters

You have your first manifesto chapters drafted and approved. They are written in your voice, drawn from your verified words, and refined through your direct feedback. Next up, you will run adversarial Counsel to challenge everything before it becomes permanent.

Run the Counsel Quality Gates

Your chapters are drafted, revised, and approved. They sound like you. But sounding right and being right are different things.

This step introduces the adversarial layer. The Counsel persona runs on a completely different AI model family (Gemini) with a prompt you authored independently in Step 2. It has one job: find where your manifesto is wrong, thin, contradictory, or unsupported. Nothing enters your final manifesto without surviving this challenge.

In this step, get ready to:

• Run adversarial counsel against your approved chapters using Gemini 2.5 Flash.
• Process severity-rated findings and close the quality loop.

Run adversarial counsel

The Counsel persona is unlike the other three agents. It runs on Gemini 2.5 Flash instead of Claude. Its system prompt was authored by you in Step 2, stored in docs/personas/counsel-prompt.md. The Ghostwriter and Interviewer never see or influence this prompt. That separation is what makes the review genuine.

Why a different model family?

If the same model that writes the draft also writes the review criteria, the review is compromised. Using Gemini for Counsel and Claude for Ghostwriter guarantees genuinely independent evaluation. The Counsel catches patterns that the drafting model is blind to by design.

• Run the counsel command in your terminal:

python -m manifesto counsel

What does this command do?

The system loads the independently-authored Counsel prompt from docs/personas/counsel-prompt.md and sends your approved chapters, identity profile, and canon claims to Gemini 2.5 Flash.

Gemini reads everything and looks for five things: contradictions the Ghostwriter missed, self-deception (you say X but your decisions show Y), narrative gaps where chapters lack evidence, unsupported claims that slipped through, and overall coherence issues. It also checks whether previous cycle findings were addressed or are still present.

The output lands in output/counsel_report.md with each finding rated HIGH, MEDIUM, or LOW severity.

• Wait for the command to complete. This typically takes 30-60 seconds depending on the size of your chapters and Gemini response time.
• Open output/counsel_report.md in your editor or Obsidian. You should see findings organized by severity (HIGH/MEDIUM/LOW) with specific references to your chapters and claims.

Seeing a 429 error?

The Gemini free tier allows 15 requests per minute and 1,500 requests per day. If you hit the rate limit, the system flags your chapters as counsel-pending and schedules a retry for the next run. Your manifesto chapters are not blocked.

Wait a few minutes and run the command again. If the error persists, you may have exhausted your daily quota. Try again tomorrow.

help me debug a Gemini 429 rate limit error in my manifesto pipeline

Process findings and close the loop

The report is not the end. It is the start of the quality loop. Each severity level triggers a different action, and HIGH findings feed directly back into the pipeline.

What do the severity levels mean?

• HIGH: Genuine contradictions, unsupported claims, or potential fabrication. These route new clarifying questions back to the Interviewer in data/interview-queue/pending.md. You must resolve them before the chapter is considered counsel-approved.
• MEDIUM: Flagged for your review but do not block promotion. These are areas where the narrative could be stronger or where evidence is thin but not absent.
• LOW: Noted only. Minor style or structural observations that do not affect accuracy or integrity.

• Check data/interview-queue/pending.md for any new clarifying questions generated by HIGH severity findings.
• If new questions appeared, answer the ones that matter. Skip the rest.
• Run the resolve command to re-process your answers:

python -m manifesto resolve-interviews

What is the continuous quality loop?

This creates a closed feedback system. Counsel challenges your chapters. HIGH findings generate Interviewer questions. Your answers clarify ambiguous claims. The Ghostwriter revises chapters based on the clarified material. Counsel re-reviews on the next cycle.

The manifesto only contains what survives this entire chain. Over time, the Counsel accumulates history and catches more subtle contradictions as your canon grows.

• Review any MEDIUM findings in your counsel report. Decide whether to address them now or let them inform future recordings.
• Verify the loop is working: your data/interview-queue/pending.md should now contain questions tied to specific counsel findings, each referencing the chapter and claim that triggered it.

No findings in the report?

If your counsel report is empty or has only LOW findings, that is fine for a first run with 1-2 recordings. The Counsel has less material to challenge. As your canon grows with more recordings, the findings become more substantive.

help me understand why my counsel report has minimal findings

Your manifesto now has a quality gate that catches what you cannot catch yourself. Next, you will generate the visual dashboard and identity report that make all of this tangible.

Generate Your Dashboard and Mirror Moment

Your manifesto has survived adversarial review. The Counsel challenged your chapters, flagged contradictions, and verified that nothing unsupported made it through.

Now it is time to see what you have built. This step produces two artifacts that make everything tangible: a visual dashboard showing your identity landscape at a glance, and an identity report that captures a timestamped snapshot of who you are right now. Then comes the mirror moment.

In this step, get ready to:

• Generate a self-contained HTML dashboard with identity visualizations.
• Produce an identity report with versioned snapshots for longitudinal tracking.
• Experience your first Mirror Moment in Obsidian's graph view.

Generate the visual dashboard

The dashboard is the public face of your manifesto engine. A single HTML file that visualizes everything: chapter progress, theme distributions, claim confidence, pipeline health, and identity drift over time.

• Generate your dashboard by running this command:

python -m manifesto dashboard

What does this command do?

Claude generates a self-contained HTML file using a system prompt that instructs it to act as a senior product designer with 15+ years of experience in data visualization and dashboard design.

The dashboard includes chapter completeness progress bars, a theme heatmap across chapters, claim confidence distribution, pipeline stage funnel, identity drift over time (comparing identity.yaml versions), revision history timeline, counsel finding trends, and a weekly activity graph. "Self-contained" means no external CDN dependencies. Everything is embedded in one file.

• Open output/dashboard.html in your browser.
• You should see a dark-themed dashboard with chapter progress bars, a theme heatmap, and identity drift visualization.

Dashboard not showing data?

• Make sure you have at least one counsel-approved chapter in data/03-manifesto/chapters/. The dashboard reads from your manifesto data to populate charts.
• If the file opens but shows blank charts, check your terminal output for errors during generation. Claude may have hit a usage limit mid-generation.
• If the file does not exist at all, confirm you ran the command from your project root directory (the folder containing your manifesto/ Python module).

Still stuck? Help me troubleshoot why my dashboard command is not generating output.

Generate the identity report with versioning

The identity report captures who you are at this moment in time. More importantly, it saves a timestamped version. Over weeks and months, these versions show how your themes, values, and positions evolve.

• Generate your identity report by running this command:

python -m manifesto report

What does this command produce?

• output/identity_report.md: Full report with manifesto progress (total words, chapters drafted, chapters approved, estimated weeks to 75k at current rate), pipeline health, identity profile, Twelve Favorite Problems, latest counsel findings, voice fidelity scores, and a "State of the Self" executive summary.
• output/identity-history/YYYY-WW-identity.yaml: A timestamped snapshot for longitudinal tracking. Each time you run the report, a new version is saved here.

• Confirm both files were created by running:

ls output/identity_report.md output/identity-history/

• You should see identity_report.md listed, plus a .yaml file inside identity-history/ named with the current year and week number.

Missing the identity history file?

• Check that the output/identity-history/ folder exists. If it was not created during the parallel build step, create it manually and rerun the report command.
• If you see identity_report.md but no YAML snapshot, the report command may have partially failed. Check your terminal for error messages about the history directory.

Need help? Help me figure out why my identity history snapshot was not saved.

Now add a Dataview query to your Obsidian vault so you can track identity drift over time.

• Open your vault index note (or create a new note called Identity Drift).
• Add the following Dataview query:

```dataview
TABLE themes, values, manifesto_progress
FROM "output/identity-history"
SORT file.name DESC
```

What does this query show?

This query pulls from every timestamped identity snapshot in your history folder. As you run the report each week, new rows appear showing which themes strengthened, which faded, and when shifts happened. Right now you have one row. In a month, you will have four. The drift becomes visible.

Your first Mirror Moment

Everything you have built across the previous steps is now connected. Transcripts link to claims. Claims link to chapters. Chapters connect to your identity profile. This is the moment you see the full picture.

• Open your Obsidian vault.
• Click the Open graph view icon in the left sidebar (it looks like a network of connected dots).
• Look at your first transcript connected to its extracted claims, connected to a chapter skeleton, connected to your identity.yaml.

These are not abstract files. They are your life, structured for the first time.

• Open output/dashboard.html in your browser again.
• See your themes visualized across chapters.
• Open one of the chapter drafts in data/03-manifesto/chapters/.
• Read the Ghostwriter's first chapter draft.

Does it sound like you? If yes, the system works. If not, that is exactly what the revision loop is for. Run python -m manifesto revise and the Ghostwriter will learn from your feedback.

Why this moment matters

You just saw yourself reflected by a system that read everything you said and organized it honestly. The graph view shows provenance. Every chapter traces back to verified claims. Every claim traces back to your own words in a recording.

The feeling of seeing your own beliefs, contradictions, and growth edges laid out for the first time is the point of this entire project. Not the code. Not the pipeline. This.

Your artifacts are real. Your system is alive. Next up, you will set up the weekly continuous delivery cycle that makes this manifesto grow on its own.

Activate Your Living Pipeline

Your manifesto engine works end-to-end. You have run every stage manually, verified the output, and seen yourself reflected for the first time.

Now it is time to make this system autonomous. A manifesto that requires you to remember to run it every week will die. A manifesto that runs itself every Sunday will compound into 75,000 words over months without you needing to think about it.

In this step, get ready to:

• Schedule the weekly pipeline to run automatically every Sunday evening.
• Run a complete cycle with new material and verify every output.
• Confirm graceful error handling, persona memory, and backup integrity.

Set up the weekly CI/CD cycle with backup

The python -m manifesto weekly command orchestrates the entire pipeline in one run. It backs up your data first, then executes every stage sequentially.

If any individual step fails (rate limit, network error, parse failure), the orchestrator skips that step, logs the failure, and continues with the remaining steps. Failed steps retry automatically on the next run.

What does the weekly command do?

The weekly orchestrator runs this sequence: backup data/ and output/ to your configured backup location, ingest new recordings, extract claims with the Interviewer persona, promote to canon, extend manifesto chapters with the Ghostwriter, run Counsel on Gemini, save an identity version snapshot, then regenerate the dashboard and report.

Nothing is lost on failure. The backup runs first, so even a catastrophic error mid-pipeline leaves your previous data intact.

• Schedule the weekly run using Windows Task Scheduler by running this command in an elevated terminal (Run as Administrator):

schtasks /create /tn "ManifestoWeekly" /tr "python -m manifesto weekly" /sc weekly /d SUN /st 20:00

What does this command do?

• /tn "ManifestoWeekly" gives the task a unique name you can find in Task Scheduler later.
• /tr "python -m manifesto weekly" specifies the command to run.
• /sc weekly sets the schedule to once per week.
• /d SUN runs the task on Sundays.
• /st 20:00 sets the start time to 8 PM (24-hour format, must be two digits for the hour).

• Verify the task was created by running:

schtasks /query /tn "ManifestoWeekly"

You should see a table showing your task name, next run time (the coming Sunday at 20:00), and status as Ready.

Change the time to suit your schedule

Sunday evening works well because it processes any recordings from the week. If you prefer a different day or time, change /d SUN to your preferred day (MON, TUE, WED, THU, FRI, SAT) and /st 20:00 to your preferred time.

Getting an access denied error?

The schtasks /create command requires an elevated terminal. Right-click your terminal application and select Run as administrator, then try the command again.

If the task creates but never runs, make sure your project path is accessible from the scheduled context. You may need to specify the full path to your Python executable and set the working directory in Task Scheduler's properties.

help me fix my Task Scheduler setup for the manifesto weekly command

Run your first complete cycle manually

Before relying on the scheduler, you need to confirm the weekly command works end-to-end with fresh material. This proves the pipeline handles new input correctly and every persona activates as expected.

• Add a second recording or transcript to data/00-raw/.

What if I do not have another recording ready?

Use the Prompt Pack to get a fresh recording by running:

• Generate recording prompts by running:

python -m manifesto prompts

Pick one prompt that resonates. Record 5-10 minutes on your phone or computer. Drop the file into data/00-raw/.

• Execute the full weekly pipeline manually by running:

python -m manifesto weekly

What should I see?

The pipeline executes each stage in order. You will see log output as it backs up your data, ingests the new recording, extracts claims with the Interviewer persona, promotes high-confidence claims to canon, extends your chapter drafts with the Ghostwriter, runs adversarial Counsel on Gemini, saves a new identity snapshot, and regenerates your dashboard and report.

If Claude rate-limits during extraction, you will see a message like "Processed X of Y transcripts. Run again tomorrow to continue." This is normal. No work is lost.

• Open your Obsidian vault. Verify new claims appear in 02-ingested/ with correct YAML frontmatter and wikilinks back to the new source transcript.
• Check that your chapter word counts in data/03-manifesto/chapters/ have increased.
• Open output/dashboard.html in your browser. Confirm the progress bars and graphs reflect the new data.
• Check output/identity-history/ for a new timestamped YYYY-WW-identity.yaml file.
• Open output/counsel_report.md and confirm it references the new material.
• Check your configured backup location. A fresh timestamped copy of your data/ and output/ folders should be there.

Pipeline skipped a step?

This is the graceful degradation working as designed. The system logs which step failed and why, then continues with the remaining steps. Check the log output for the specific error message.

Common causes: Gemini rate limit (Counsel step skipped, retries next run), Claude usage limit (extraction processes partially, resumes next run), or a parse failure on a malformed transcript (that file is flagged, others proceed normally).

my weekly pipeline skipped a step and I want to understand why

Validate the living system

The final check confirms your system is genuinely alive. Not just running, but learning. Each persona should demonstrate memory of previous interactions.

• Check error handling by running:

python -m manifesto health

You should see all steps reporting clean with no steps in retry-pending state. If anything shows as pending, it means a previous failure has not yet been retried successfully.

• Verify persona memory by checking these indicators:

• The Ghostwriter references your voice-guide.yaml preferences in its chapter drafts. Open a recent chapter and confirm the tone matches what you specified during onboarding.
• The Interviewer references previous claims when asking new questions. Check data/interview-queue/pending.md for questions that cite earlier material.
• The Counsel does not repeat previous findings. Compare output/counsel_report.md across runs. New findings should address new material, not rehash old ones.

• Verify backup integrity by checking your configured backup location. You should see a timestamped copy of everything from each run.

What does a healthy system look like?

Every week you talk. Every week the system listens. Every week your manifesto grows toward 75,000 words. Not because AI invented something about you. Because four expert agents organized what was already there, challenged it honestly, and wrote it in your voice.

The system compounds. The Ghostwriter gets better at your voice with every revision. The Counsel catches more subtle contradictions as it accumulates history. The identity snapshots in output/identity-history/ track your evolution over months.

Health check showing retry-pending steps?

Run python -m manifesto weekly one more time. The retry logic picks up any previously failed steps and attempts them again. If the same step fails twice, the issue is likely environmental (network connectivity, expired API key, or rate limit still in effect).

my manifesto health check shows steps stuck in retry-pending state

Your pipeline is alive. From here, your only job is to keep talking. Drop recordings into data/00-raw/ whenever something true comes out of your mouth. Sunday evening, the system takes it from there.

Secret mission

Brand Voice Export

Your manifesto holds verified truths about who you are. But when someone asks 'So what do you do?' at a networking event, you freeze. This mission turns your canon claims into immediately usable brand assets: a positioning statement, elevator pitch, LinkedIn summary, and conversation starters. All sourced from YOUR verified words. All checked by the Ghostwriter for voice fidelity. All reviewed by Counsel for unsupported claims.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally. There are no ongoing cloud costs, no running servers, and no metered API charges beyond the free tiers you already have.

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

• Project folder on your Desktop (all pipeline code, data, personas, manifesto chapters).
• Backup folder at your configured backup location.
• Windows Task Scheduler task for the weekly pipeline run.
• Gemini API key in Google AI Studio (free tier, no charge).
• Python packages installed via pip (faster-whisper, google-generativeai, pydantic, pyyaml).
• Claude Code CLI installed globally via npm.
• Obsidian vault with Dataview plugin (local files, no charge).

Keep everything running

No action needed. Choose this if you are still actively building your manifesto.

• The weekly cycle runs at zero ongoing cost. Your manifesto grows chapter by chapter toward 75,000 words.
• The Ghostwriter gets better at your voice with every revision. The Counsel catches more subtle contradictions as it accumulates history.
• Identity versions track your evolution over months. Over a year you build the most comprehensive, verified self-portrait anyone has ever created for themselves.
• Claude Code, Node.js, Python, and Obsidian remain installed on your machine for other projects.

Pause - I'll come back to this later

Shut down the scheduled task to free up background processing. All files, agent memory, and backups remain on disk. Resume anytime and they pick up where you left off.

• Open Task Scheduler (press the Windows key, type Task Scheduler, press Enter).
• Find your manifesto weekly task, right-click it, and select Disable.
• Your project folder, backup folder, and Obsidian vault stay untouched. Re-enable the task whenever you are ready to resume.

Delete - I don't want to use this again

Remove all project resources and start fresh. Your data never left your machine. Backups remain at your configured location until you manually delete them.

• Delete the Windows Task Scheduler task by opening a terminal as Administrator and running:

schtasks /delete /tn "ManifestoWeekly" /f

• Delete your project folder by running:

rmdir /s /q %USERPROFILE%\Desktop\manifesto-engine

• Delete your backup folder at your configured backup location (e.g., OneDrive, external drive). Navigate to that location and remove the manifesto backup directory.
• Delete the Obsidian vault data. In Obsidian, right-click the manifesto vault in the vault switcher and select Remove vault. Then delete the folder from disk:

rmdir /s /q %USERPROFILE%\Documents\manifesto

• Revoke your Gemini API key. Go to aistudio.google.com/apikey, find the key you created for this project, click the trash icon next to it, and confirm deletion.
• Uninstall the Python packages by running:

pip uninstall faster-whisper google-generativeai pydantic pyyaml -y

• Uninstall Claude Code by running:

npm uninstall -g @anthropic-ai/claude-code

• Remove the config.yaml reference from your environment. If you set a GEMINI_API_KEY environment variable, remove it from your system environment variables (Settings > System > About > Advanced system settings > Environment Variables).

That's a Wrap!

That's a Wrap!

You built the architecture for your own manifesto. A team of four expert agents now works for you every week, turning scattered voice recordings into a verified, chapter-by-chapter account of who you are.

Here's what you accomplished:

• Designed and built a complete CI/CD data pipeline (raw to staged to ingested to canon to manifesto) with quality gates at every transition, constructed by three parallel Claude Code agents working simultaneously in isolated git worktrees.
• Defined four expert agent personas (Ghostwriter, Interviewer, Counsel, Architect) with persistent memory, voice fidelity verification, revision loops, and adversarial independence guarantees across model families.
• Produced a growing multi-chapter manifesto with an interactive HTML dashboard, identity versioning over time, automated weekly backups, and a queryable Obsidian vault with Dataview frontmatter, wikilinks, and sensitivity controls.
• Exported your verified identity as ready-to-use brand assets including a positioning statement, elevator pitch, and LinkedIn summary. All voice-checked, sensitivity-screened, and counsel-approved.

The system does not tell you who to be. It shows you who you already are. Now you can work with that.

Ready to quiz yourself?