importing-chatgpt-memory

What this skill does

# Cloning ChatGPT Memory into Letta

Use this skill when a user wants Letta to inherit ChatGPT memory as faithfully as possible without blindly importing an entire export.

## Good fits

- clone my ChatGPT memory into Letta
- inspect hidden saved profile / custom-instruction context
- migrate ChatGPT memory into active Letta memory
- enrich the clone with work context or collaboration preferences from old chats
- preserve selected transcripts for high-fidelity audit/reference

The skill should work well even when the user says something minimal like:
- "I want to import my ChatGPT memory"
- "Can you clone my ChatGPT memory into Letta?"
- "Import my ChatGPT export"

Do **not** depend on the user writing an optimized prompt.

## Scope

This skill is for **memory onboarding**, not just transcript rendering.

It should:
- extract ChatGPT saved memory and editable-context blocks first
- build a Letta-oriented preview of what should become active vs progressive memory
- write obvious, high-confidence items while narrating progress
- optionally enrich from the broader archive afterward
- optionally export transcripts for high-fidelity archival

It should **not**:
- blindly import the whole archive
- treat runtime context as durable memory
- flatten historical context into always-visible memory by default
- auto-store sensitive personal material without confirmation
- write memory into a malformed MemFS structure

## Default posture

Use a **clone first, enrich second** workflow.

1. ask a short structured intake
2. inspect the export
3. extract and preview in one step
4. write obvious high-confidence items while learning
5. continue into archive enrichment if scoped — narrate progress, let the user interrupt
6. ask only at meaningful checkpoints
7. run `/doctor` to validate the final memory structure

Users should feel like they are being guided through an onboarding flow, not dropped into a bag of scripts.

The onboarding should be robust to sparse user input. The agent should supply the structure, not ask the user to craft a better request.

**This skill is a workflow, not reference material.** Follow the numbered steps in order. Read the guidance for each step before executing it — especially the merge rules and write targets. Moving fast is good; skipping steps is not. "Autonomous" means you drive the process without stopping for permission, not that you skip the instructions.

## Interaction style

### Start with a short dialog

When available, prefer the structured **AskUserQuestion** flow so the import feels like a dialog.

Good question types:
- export location (if not obvious)
- import scope (saved memory only, memory + work context, full history mining)
- topic focus: "Any specific projects or topics you want me to look for?"
- sensitivity: "Anything I should avoid storing?"

Do **not** ask about review cadence. Most users don't have a strong preference, and the ones who do will say so. Default to keeping going — narrate what you're doing and let the user interrupt if they want to pause. This keeps the flow moving instead of creating a false checkpoint.

Avoid questions that don't actually change the workflow. For example, "how do you want historical context handled?" sounds meaningful but the answer rarely changes what scripts you run. Focus on questions whose answers fork the process.

This intake exists so the user does **not** need to front-load all of this context in their first message.

Use:
- **single-choice** for policy decisions
- **multi-select** for scope selection

### After intake, drive the process

Once scope is clear, be more authoritative than permissive.

Do **not** keep returning with vague prompts like:
- "what do you want me to do next?"
- "should I keep going?"

Instead:
1. say what you wrote
2. say what you are reviewing next
3. continue automatically

Only stop for:
- contradictory facts
- sensitive/intimate material
- major scope changes
- real uncertainty about what counts as durable memory

Do **not** stop for low-risk routing decisions once the user's scope is already broad and clear.

Also do **not** respond by teaching the user how they should have phrased the request. Just run the onboarding properly.

## Progress tracking

This import can take multiple minutes for large archives. **Never let the user sit in silence.** The import should feel like a guided, living process.

### Record the starting commit

Before writing any memory, record the current HEAD of the memory repo:

```bash
git -C "$MEMORY_DIR" log --oneline -1
```

Save this commit hash — it's the rollback point. If anything goes wrong or the user wants to undo the import, they can reset to this commit:

```bash
git -C "$MEMORY_DIR" reset --hard <start-commit>
git -C "$MEMORY_DIR" push --force
```

Include both the start and end commit hashes in the import audit file and in the final summary. Tell the user explicitly: "If you want to undo any of this, I can reset your memory to where it was before the import."

### Use TodoWrite for phases

Create a todo list at the start of the import and update it as you go:

1. Record starting commit
2. Locate export and run inventory
3. Extract and preview saved memory
4. Write active memory (`system/human.md`)
5. Write import audit + progressive memory (`reference/chatgpt/`)
6. Archive enrichment (if scoped)
7. Validate with /doctor

Mark each phase `in_progress` before starting and `completed` when done.

### Narrate between script calls

After each script completes, tell the user what you found before running the next one:

- "Found 347 conversations spanning 2023–2026. Extracting saved memory now..."
- "ChatGPT remembered 12 facts about you across 4 fields. Building the preview..."
- "Writing 8 high-confidence items to active memory. Next: archive enrichment..."
- "Dispatching 4 mining agents across 200 conversations..."

### Report stats

Surface concrete numbers whenever you have them:
- total conversation count
- saved-memory field counts
- how many items written vs held for review
- mining progress (conversations scanned, findings per chunk)

### Use --progress on scripts

All long-running scripts support `--progress` which prints status to stderr. Use it for large archives so the user sees work happening even during script execution.

## Workflow

### 0. Locate the export

ChatGPT exports are typically named with a long hash and timestamp, e.g.:
`8a8f3ee0...-2026-03-31-18-41-51-e0dc362a....zip`

Common locations:
- `~/Downloads/` (most common — this is where the browser saves it)
- Desktop or a custom export folder

If the user doesn't know the exact path, glob for zip files in Downloads:

```bash
ls -t ~/Downloads/*.zip | head -20
```

Downloads folders are often crowded. ChatGPT exports follow a distinctive pattern — look for filenames matching `[8+ hex chars]-YYYY-MM-DD-*`. A quick filter:

```bash
ls ~/Downloads/*.zip | grep -E '[0-9a-f]{8}.*-[0-9]{4}-[0-9]{2}-[0-9]{2}-'
```

If still ambiguous, check whether the zip contains `conversations-*.json` entries:

```bash
unzip -l <candidate.zip> | grep conversations-
```

### 1. Inventory the export

Start by listing conversations and surfacing hidden-context-heavy candidates.

```bash
python3 scripts/list-conversations.py <export.zip>
python3 scripts/list-conversations.py <export.zip> --sort hidden --min-hidden 1
python3 scripts/list-conversations.py <export.zip> --json --limit 50
```

Use this to understand scale, find likely memory-heavy conversations, and decide whether broader archive review is even necessary.

**Warning:** For large archives (300+ conversations), `--json` output can easily exceed 100K characters and flood your context window. Mitigations:
- Use `--limit 50` to start — you can always paginate with `--start-index`
- Pipe to a file and read selectively: `... --json > /tmp/conversations.json`
- Use `--title-contains` to filter before dumping JSON
- The non-JSON (table) output is much more compact for initial inventory

### 2. Extract and p