PAI
Productivity Standard

Migrate

Intakes external content, classifies chunks against PAI taxonomy, commits with provenance.

00
Workflows
00
References
08
Triggers
medium
Effort

The Problem

When you have years of notes, old PAI installs, Cursor rules, Obsidian vaults, or journal dumps sitting outside your current system, a generic AI will happily paste things in random places or ask you to sort every line yourself. It has no model of where a belief vs. a goal vs. a feedback rule belongs. You end up either doing all the routing by hand, or trusting the model's flat intuition and watching your TELOS files turn into garbage heaps.

How This Skill Approaches It

Migrate runs a real classification engine against the PAI taxonomy before touching anything. MigrateScan.ts reads your source — a file, a directory, stdin, an Obsidian export, a .cursorrules file — breaks it into chunks, scores each chunk against every destination in the PAI taxonomy (TELOS sections, IDEAL_STATE dimensions, MEMORY/KNOWLEDGE types, feedback memory files, PRINCIPAL_IDENTITY), and produces a routing table with per-category confidence scores. Chunks that score ≥70% go to a fast-approve path. Those in the 40–70% band surface for confirmation. Anything below 40% goes to a walk-through queue where you decide. MigrateApprove.ts commits with provenance comments so nothing lands without attribution. PRINCIPAL_IDENTITY changes always prompt regardless of confidence — that file is load-bearing.

  • Sources: .md/.txt, stdin, PAI dirs, CLAUDE.md/Cursor/OpenAI Custom Instructions, Obsidian/Notion/Apple Notes exports
  • MigrateScan classifies → routing table
  • MigrateApprove with --approve-all/--approve-target/--review/--dry-run
  • Confidence ≥70% auto, 40-70% confirm, <40% walk-through
Not for single-file edits, conversational interviews, identity edits

In Action

What you say to your DA, and what the Migrate skill actually does.

  • You say "migrate my old pai install's telos directory"
    Runs MigrateScan.ts against the old TELOS/ path, produces a routing table showing how many chunks map to GOALS, WISDOM, BELIEFS, etc. with average confidence per target, then walks through approval — fast-approve trusted items, step-by-step on anything uncertain.
  • You say "import my cursor rules file into the system"
    Scans the .cursorrules file, classifies most lines as feedback memory rules (the 'always do X / never Y' patterns), flags any identity-adjacent lines for confirmation, and commits each approved chunk to its own feedback_migrated_<slug>.md file with source attribution.
  • You say "i dumped a bunch of old journal notes into /tmp/journal.md — bring them in"
    Scans the journal, expects a high proportion of WISDOM and UNCLEAR chunks, presents the routing summary, then steps through low-confidence and unclassified sections one at a time so you make the call on each one.

Inside the Skill

The thinking, frameworks, and architecture that distinguish this skill from a generic version of the same task.

What It Does

Migrate intakes external content, classifies each chunk against the PAI taxonomy, and commits it to the right destination with provenance. Sources include .md/.txt files, stdin, other PAI installs, agent-harness rule files (CLAUDE.md, Cursor rules, OpenAI Custom Instructions), and Obsidian/Notion/Apple Notes exports. Classification confidence drives the flow: high-confidence chunks auto-approve, medium ones ask for confirmation, low ones get a walk-through.

The Problem

When you adopt PAI you usually arrive with years of accumulated notes — a CLAUDE.md, a vault of markdown, journal dumps, rules from another tool — and none of it maps cleanly onto PAI's structure. Sorting hundreds of chunks into TELOS sections, knowledge notes, and feedback rules by hand is the kind of tedious work that never gets done, so the old material just sits there unused. Migrate does the sorting: it reads the content you already have, proposes a destination for every chunk with a confidence score, and lets you approve in bulk or review the uncertain ones, attaching provenance so nothing lands in TELOS without attribution.

How It Works

Migrates content into the PAI structure from external sources. Unlike /interview (which asks the user questions to fill gaps), /migrate already has the content — it just needs to classify each chunk and route it to the right PAI destination. MigrateScan classifies into a routing table; MigrateApprove commits per the user's chosen path.

Sources supported in V1

  • Files: .md, .markdown, .txt (single file or directory recursion)
  • Stdin: piped content or pasted directly
  • Other PAI installs: point at their USER/TELOS/ or MEMORY/KNOWLEDGE/ directories
  • Agent-harness rule files: CLAUDE.md, .cursorrules, OpenAI Custom Instructions export
  • Exports: Obsidian vaults (markdown), Notion exports (markdown), Apple Notes exports (.txt), raw journal dumps

What it classifies chunks into

Category Destinations
Foundational TELOS MISSION, GOALS, PROBLEMS, STRATEGIES, CHALLENGES, BELIEFS, WISDOM, MODELS, FRAMES, NARRATIVES, SPARKS
IDEAL_STATE dimensions HEALTH, MONEY, FREEDOM, RELATIONSHIPS, CREATIVE, RHYTHMS
Preference files BOOKS, AUTHORS, MOVIES, BANDS, RESTAURANTS, FOOD_PREFERENCES, LEARNING, MEETUPS, CIVIC
Identity USER/PRINCIPAL/PRINCIPAL_IDENTITY.md
Knowledge MEMORY/KNOWLEDGE/{Ideas,People,Companies,Research}
AI collaboration rules memory/feedback_*.md (for "always do X", "never Y" patterns)
Unclear Flagged for the user's manual routing

Workflow

Phase 1 — Identify the source

Ask the user what he wants to migrate:

  • "Paste the content here and I'll work from stdin"
  • "Point me at a file path"
  • "Point me at a directory and I'll scan everything inside"
  • "I have a Cursor rules file at ~/Projects/X/.cursorrules"
  • "My old PAI install has TELOS at ~/old-claude/TELOS/"

Collect the source path. If content is pasted, write it to a temp file first.

Phase 2 — Scan

Run the scanner:

bun ~/.claude/PAI/TOOLS/MigrateScan.ts --source <path>
# or
echo "$CONTENT" | bun ~/.claude/PAI/TOOLS/MigrateScan.ts --stdin

Scanner output includes:

  • Total chunks found
  • Proposed routing table (how many chunks per target)
  • Average classification confidence
  • Count of UNCLEAR chunks
  • Count of low-confidence (<40%) chunks

Phase 3 — Present routing summary

Show the user the routing proposal in a scannable format:

Found 47 chunks from 3 files. Proposed routing:

  📂 TELOS/GOALS.md              12 chunks  (78% avg confidence)
  📂 TELOS/WISDOM.md              8 chunks  (65% avg confidence)
  📂 TELOS/BELIEFS.md             6 chunks  (71% avg confidence)
  📂 MEMORY/KNOWLEDGE/Ideas      15 chunks  (52% avg confidence)
  🧠 memory/feedback              4 chunks  (85% avg confidence)
  ❓ UNCLEAR                      2 chunks  (needs your call)

Options:
  - Approve everything trusted (confidence ≥60%)?
  - Walk through the low-confidence and UNCLEAR chunks one by one?
  - Review specific categories?
  - Review everything?

Phase 4 — Approval loop

Based on the user's preference:

Fast path (he says "approve all trusted"):

bun ~/.claude/PAI/TOOLS/MigrateApprove.ts --approve-all

Commits everything non-UNCLEAR. Then walk through UNCLEAR chunks conversationally.

Category path (he says "approve goals and wisdom, skip knowledge"):

bun ~/.claude/PAI/TOOLS/MigrateApprove.ts --approve-target TELOS/GOALS.md
bun ~/.claude/PAI/TOOLS/MigrateApprove.ts --approve-target TELOS/WISDOM.md

Walk-through path (he wants careful review):

bun ~/.claude/PAI/TOOLS/MigrateApprove.ts --review

Show each pending chunk. For each:

  • Show preview + proposed target + confidence + alternatives
  • Ask: approve / modify target / reject
  • Commit decision

Phase 5 — Handle UNCLEAR chunks

UNCLEAR chunks are ones where no classification rule matched strongly. For each:

  • Display full content (not just preview)
  • Ask the user: "This one's unclear — what is it? Could be X, Y, Z, or maybe Knowledge/Ideas as a catch-all?"
  • the user chooses → commit via --modify <id> --target <chosen>

Phase 6 — Completion summary

After approval pass:

  • Report total chunks committed, per-target count
  • Flag any remaining UNCLEAR
  • Recommend next step: run /interview to interview around anything the migration left sparse

Rules

  • Every commit carries provenance. The committed content includes an HTML comment noting source file + section + timestamp. Nothing gets dropped into TELOS without attribution.
  • Never bulk-approve UNCLEAR. Those require the user's explicit routing.
  • Confidence thresholds: ≥70% = trusted (auto-approve eligible). 40-70% = medium (show for confirmation). <40% = low (walk-through required).
  • Ask before touching identity. PRINCIPAL_IDENTITY.md commits always prompt — that file is load-bearing.
  • Don't duplicate. If the same content already exists in the target (substring match), flag it and ask before appending.
  • Respect private paths. Never migrate content into IDEAL_STATE/ without the user's per-dimension call (Decision #3: IDEAL_STATE is fully private and curated).
  • Feedback memories get new files. Each memory/feedback chunk becomes its own feedback_migrated_<slug>_<id>.md file — not appended to an existing memory.
  • Knowledge gets new files too. Each MEMORY/KNOWLEDGE/* chunk becomes a new typed note with source metadata.

Examples

User: /migrate ~/old-claude/TELOS/

the DA scans the old TELOS directory, classifies every chunk, presents the routing summary, offers fast-path vs. walk-through approval.

User: /migrate (then pastes CLAUDE.md content)

the DA reads from stdin, classifies the rules as memory/feedback (most) plus maybe PRINCIPAL_IDENTITY (if identity lines are mixed in), walks through approval.

User: "migrate my Cursor rules at ~/.cursor/rules"

the DA scans the rules dir, surfaces likely-feedback classifications, walks through with extra care (Cursor rules often have tool-specific stuff that doesn't translate to PAI).

User: "import the stuff I dumped in /tmp/journal.md"

the DA scans the journal, expects a lot of UNCLEAR + WISDOM, walks through each section.

Related

  • /interview — fills gaps by asking questions (not by intaking existing content)
  • /Telos Update workflow — edit a single TELOS file directly
  • /Knowledge — manage the Knowledge Archive
  • /_PROFILE — manage PRINCIPAL_IDENTITY

Troubleshooting

  • Low average confidence (<40%): the source is probably genre-mismatched (e.g., code comments, logs, raw data). Consider pre-filtering to remove non-prose chunks before scanning.
  • Everything goes to UNCLEAR: the source probably has no recognizable PAI-taxonomy patterns. Either add the content manually via /Telos or write it as general Knowledge notes.
  • Duplicate content warnings: the scanner doesn't dedupe against existing files yet. Run --dry-run first to preview before committing.

How to Invoke

Say any of these to your DA and PAI activates the Migrate skill automatically:

  • "/migrate"
  • "migrate content"
  • "import from other PAI"
  • "bring in old notes"
  • "import Cursor rules"
  • "import CLAUDE.md"
  • "bulk import"
  • "Obsidian/Notion/Apple Notes import"

Or invoke explicitly:

Skill("Migrate")

Want PAI to do this for you?

Install PAI on your machine — your DA gets the Migrate skill plus 44 others, all hooked into one Life OS.

Install PAI View on GitHub