The Dossier
Personal Project Memory and Production System
I built a private project-memory and source-recovery system to organize years of ideas, corrections, files, and AI conversations without relying on model memory alone.
Overview
Over several years, I used ChatGPT to research ideas, solve practical problems, write code, analyze data, build prototypes, and develop creative and technical systems. The work existed, but it did not exist in one reliable place.
Important definitions were buried inside individual conversations. Related projects were separated by months. Names changed. Assistant suggestions could be confused with my own ideas. Recent projects could be overweighted because the system could not see the full history. Even a project as specific as VCGU could be misremembered as “virtual” instead of “vehicle.”
The Dossier was created to solve that problem. It preserves raw source material, extracts project candidates, records aliases and corrections, separates evidence from interpretation, and turns fragmented history into a structured environment for evaluation and production.
It is also the recovery layer behind Curious Minds. The current project pages were strengthened by using the Dossier to return to raw conversations, locate original files, distinguish completed work from speculation, and correct first-pass summaries.
How It Started
The Dossier began on June 7, 2026 during a discussion about which personal project Codex should help build. When VCGU was temporarily misframed as a virtual CGU, the correction exposed a larger problem: years of project meaning were being flattened across long AI histories.
I realized that the ideas would remain difficult to access and move into production unless the source conversations were collected and organized outside of model memory. The solution was not another summary. It was a local, inspectable, versioned system built from the exported context itself.
The original workflow goal was straightforward: preserve the export, scan it with local tools, identify project candidates, link related records, keep ambiguity visible, and create a source-of-truth layer before making build or publication decisions.
How can a long-running AI collaboration preserve project truth when conversation history is too large, fragmented, and changeable to remain reliable through memory alone?
Architecture
Raw Source Archive
The source layer preserves exported conversation JSON, HTML, attachments, asset references, and local project files. Raw inputs remain separate from rewritten summaries.
The initial scan foundation contained:
- 57 conversation JSON files;
- 5,609 conversations;
- 47,112 messages.
Extraction and Recovery Layer
Local Python tools scan the archive for project names, aliases, technical phrases, filenames, corrections, dates, and evidence-bearing messages. Extraction tools accelerate discovery but do not become the source of truth themselves.
Knowledge Layer
The Dossier organizes the results into:
- project and idea records;
- research and work-system records;
- source manifests;
- indexes;
- relationship maps;
- recovery logs;
- decision records;
- open questions;
- review queues.
Review-First Ingestion
New evidence is staged for review rather than silently overwriting stable records. Later user corrections outrank earlier assistant summaries, and raw timestamps outrank derived dates.
A priority scorecard and project records help distinguish what is ready to build, what is ready to publish, what needs more evidence, and what should remain parked. Public pages use sanitized conclusions rather than exposing the private archive.
Development Timeline
Project origin
The need for a structured project-memory system became explicit after project context and terminology drifted across conversations.
Initial extraction layer
Folder structure, templates, extraction scripts, project candidates, review categories, and an early priority scorecard were created.
Repository expansion
Source manifests, architecture, ingestion rules, taxonomy, indexes, project records, recovery notes, and review queues developed into a durable Markdown repository.
Stronger source and recovery model
The Dossier formalized source hierarchy, clustering, incomplete-evidence handling, and the rule that ingestion should produce candidates before changing records.
Curious Minds reconstruction
The Dossier and raw export were used to recover deeper histories, original scripts, logs, images, and corrections for CGU, VCGU, CleanStop, PUNCH, and QCGU.
Results and Current Boundaries
Source truth preserved
Raw exports and original files remain separate from derived records, allowing later summaries to be checked and corrected.
Project relationships made navigable
Aliases, branches, project families, and evidence quality can be mapped without forcing unrelated ideas together or losing historical names.
Build and publication decisions improved
The system creates a clearer distinction between implemented prototypes, completed workflows, active alphas, conceptual research, and ideas that still need recovery.
AI limitation converted into architecture
Context loss is no longer treated only as a conversational inconvenience. It became the design problem that the Dossier is built to manage.
The Dossier is a working private system, not a public archive of personal conversations. Public documentation should show sanitized process, structure, and results without exposing confidential work, health, family, account, or unreleased project information.
Behind the Build
The Dossier is the system behind the project pages. It helps me return to the original record, separate my decisions from assistant suggestions, and keep corrections from disappearing as conversations become too large to hold in context.
What I built
A local Markdown repository and Python-assisted workflow that scans exported conversations, identifies project candidates and aliases, preserves corrections, links evidence, and creates reviewable records before anything becomes public portfolio copy.
The key idea
Extraction is not treated as truth. Raw statements and files remain above summaries, and every correction has to remain visible so a convenient interpretation cannot silently replace the original project definition.
Selected technical detail
Finding projects while preserving corrections
if "correction" in text.lower():
corrections.append(record)
for name, aliases in project_aliases.items():
if any(term.lower() in text.lower()
for term in [name] + aliases):
candidates[name].add(record_id)This shortened example shows the two jobs happening together: locate possible project records, but also preserve the moments where a name, date, or interpretation was corrected.
Evidence to show on the page
These are the strongest visual proof points for a recruiter or technical reviewer. The image and video URLs can be inserted after the Squarespace asset list is finalized.
A sanitized view of project records linked back to their original sources.
Candidate records waiting for human review rather than being accepted automatically.
A redacted example showing how an incorrect interpretation is retained and corrected.