LifeOS 7.40.4 — The Receipts Release

Thirteen days, 61 substantive changes, 30 community fixes, and one theme: the system now proves what it claims.

The oldest complaint about AI systems, this one included, is that they say "done" when they aren't. A run reports success and the test never ran. A dashboard glows green over data that doesn't exist. An installer corrupts the thing it installs and exits zero. Since 7.28.3, most of what we shipped attacks that gap from a different angle, and the community found more of it than we did. This release is where a lot of that work lands at once.

The Algorithm: the hill-climb you can see, and can't fake

The Algorithm went from 8.17.3 to 8.20.2, and the thread through every change is honesty about where a run actually is.

• The phase strip. Long runs now show their climb in the response itself, and the strip is computed by a hook from the run's real state; the model just echoes it. This exists because we caught a run claiming it was ascending while the board derived from the same data said it was still traversing. The model can no longer say one thing while the state says another; both read from one source.
• Euphoric surprise is now the meta-ideal-state of every ISA. Each ISA names the specific ideal state of one piece of work. Above every one sits the same universal goal: the person using the system gets exactly what they wanted, at the right speed, for the right spend. The doctrine now says this out loud, and the specific climb and the general one are one motion.
• Delegate briefs sized by blast radius. When the Algorithm hands work to a subagent, the brief's depth now scales with what the work can break, so trivial legs stop carrying ceremony and dangerous legs stop going out underspecified.
• ISA verifier classes and execution tiers. Claims now declare what kind of evidence closes them, and the machinery routes each claim to a verifier that can actually produce that evidence. "Should work" was already banned; the ban now has enforcement machinery behind it.

Everything ships with receipts: the release pipeline grew teeth

Users kept finding things in the public payload that our gates missed: dead template tokens, files that reference machinery that never ships, a maintainer's runtime state where a template belonged. Every one of those reports became a permanent, deterministic gate. The cut pipeline now runs 23 build gates plus a set of emit gates, and this cycle alone added checks for unrendered placeholders in live code, references to per-instance state files that never ship, retired capabilities still described as live, incident identifiers in shipped prose, hardcoded voice IDs in templates, and maintainer-only instructions presented to fresh installs as things they can run.

On top of the gates, every cut now ends with two independent read-only audits: a cross-vendor model reviewing the payload from outside our model family, and a fresh-context in-family pass attacking with insider knowledge. Findings from either block the release. The rule that makes this compound: every finding must also become a deterministic catch, so the same class can never need an audit again.

The community wave: 30 fixes from the people running this thing

Two triage rounds in this span ported 30 community contributions, and the reports were unusually good: reproduction tables, traced root causes, proposed diffs that survived review nearly unchanged.

Highlights, with the people who found them:

• Install no longer corrupts its own payload. The identity-substitution pass walked into the redistribution copy and baked one user's name into ~121 template files. Found by @Piroshki, root-caused by @DRAZY, fixed at the walk. Related: file modes now survive substitution, so hooks stop silently losing their execute bit (@alloutflo, @mark-219).
• Session names stop being word salad. The last-resort naming strategy planted a verb that let any four words pass validation, which turned non-English prompts into nonsense titles. Deleted; an unnamed session now just retries. Task verbs like "complete" and "finish" are also no longer banned from leading a name (@xmasyx).
• Voice lines survive a misnamed DA. If your assistant's configured name didn't match what it wrote, the system silently spoke a CHANGE bullet instead of the closer, for days. Extraction is now anchored to your configured name first with a safe fallback, and the fallback logs itself (@MatiasBarboza).
• Dashboards read the data that's actually there. The life hero rendered "Unknown, Unknown energy" while populated data sat one parser away; the check-in invented two of its three numbers; ISA progress mismatches were detected and then logged to nowhere. All fixed (@jacobo-ortiz, who filed seven forensic reports in one day).
• Forked subagents are now detected (@DRAZY), the proposal parser stops eating ordinary messages that start with "no" (@xmasyx), iMessage sending works on current macOS (@J0UH), the memory reviewer can no longer resolve a conflict it cannot source and stamp it as your stated fact (@Chuckos), and the DA identity template ships the schema its own docs define (@justinkatz94-glitch).

Pulse: a dashboard that ships working

The Pulse dashboard's static export is now actually in the release. Every prior release silently dropped it: 181 files swallowed by a gitignore rule, so fresh installs got a dashboard they had to build themselves. Now localhost:31337 works out of the box. Alongside it: scheduled jobs never voice-notify anymore (your cron jobs stop talking at 3am), a new guard blocks headless sessions from reaching the speaker at all, and the statusline gained a privacy overlay for security-engagement work.

Cortex, and the rest of the new machinery

• Cortex consolidation. The memory system's skills merged into one, with a weekly Distill pass that compresses accumulated knowledge before it silts up.
• Helm ships self-contained. The LifeOS terminal (kitty config layer, installer, app wrapper) now lives inside the release, with its installer hardened through three rounds of destructive-edge review.
• New skills: Novelty (evolutionary explanation-discovery for hard problems), SecurityMarketData (curated cybersecurity market intelligence), Vitals (macOS performance diagnostics), Share (self-hosted file sharing), and DetectAI grew deterministic statistical signals plus keyless watermark and steganography scanning.
• Hermes gained a zero-token heartbeat: calendar, mail, and queue ticks every ten minutes as pre-run scripts, so the sidecar stays current without burning a single model call.
• Vulnerability management now cross-references CISA KEV with a page-now override, and a new advisory ComplexityRatchet meter flags complexity drift on every edit without ever blocking one.
• Bunker joined the core component roster: the universal application harness's concept docs ship, with the reference implementation staying private by design.

For the people who asked "should I upgrade?"

A few discussion threads this cycle asked whether 7.x is worth it from 4.x or 5.x, and one user's DA even flagged our own installer as suspicious before recommending against upgrading. Fair. The honest answer is that this line of releases is specifically about making the system prove itself: commit-pinned downloads with printed checksums, an installer that backs up before it touches anything and restores itself if interrupted, gates that block us from shipping our own private data, and a dashboard that works on first boot. That is also why these notes walk through the work in detail: the receipts are the point.

Every contributor named above is also credited at the fix site in source and in the README. If you filed something that isn't here, it's tracked, and the next release's notes will say where it landed.

LifeOS is the AI harness that moves you from your current state to your ideal state—an intent engineering platform. It captures what you're ultimately trying to achieve, conveys that intent to your AI on every task, and verifies the output against it.

This is the largest release since 7.0. It spans 27 feature versions of work (v7.1.1 → v7.28.3): the thinking system gained a runtime enforcement layer, the memory system got a name and an autonomic curation loop, several core subsystems became named products with real narratives, a second front door opened, and the release pipeline got harder to leak through.

The Algorithm: doctrine with runtime teeth

The Algorithm—the loop that articulates what "done" means, hill-climbs toward it, and closes claims only on tool evidence—advanced fourteen feature versions this cycle (v8.3 → v8.17). The bigger change: compliance is now enforced by deterministic hooks that check the work as it happens.

AlgorithmNudge unifies what used to be four separate nudge mechanisms (skill routing, late-ISA, spend discipline, ISA hygiene) into one runner with always-on and run-scoped checks. When a run skips a step the doctrine requires, the hook says so at the moment it happens, and every fire is logged as telemetry so the nudge layer can be tuned from real data.

ISA close teeth. An ISA (Ideal State Artifact) is the file that holds what "done" means for a piece of work. Three new gates keep it honest at the close: ISACloseGate blocks completion claims when the ISA is provably stale (it counts tool calls since the last ISA edit), ISAGate blocks structurally invalid phase: complete writes, and StopGates runs structural checks when a session tries to end. Work only closes when its definition of done matches what was actually built.

Six-state ascent vocabulary. Every surface that shows what a run is doing—terminal tabs, the status line, the Pulse work board, the ISA mirror—now reads from one six-state table, with an integrity-check gate that fails on any hand-spelled state name. One vocabulary, everywhere, enforced.

Model routing by role. Doctrine used to name specific models, which silently rotted every time a new model shipped. It now speaks in roles (session default, one rung down for execution, escalation rung) carried by tier aliases that always resolve to the latest model in that tier. A new model release propagates through the entire system with zero edits.

Cortex—the memory system, named

Everything LifeOS knows now has a product identity: hot-layer memory injected every turn, a typed Knowledge Archive (People, Companies, Ideas, Research), learnings, and work history. Named for where the brain stores long-term memory: hooks and an autonomic reviewer consolidate what each session taught, and the tiered store keeps it, so every session starts smarter than the last. The new KnowledgeWriteGuard hook gives Knowledge notes schema feedback at write time, keeping the archive a typed graph.

Hermes sidecar—talk to your LifeOS as an agent

An optional second front door that mounts your install: same constitution, same identity, same skills, same sense of what's sensitive, reachable from a terminal. One brain, another way in. Hermes ships with a health contract, so a failed sidecar pages you.

Named subsystems with real narratives

Four more parts of the system graduated from "some files" to products within the product:

• Synapse—the input router. Every capture surface plugs into one contract: capture → write-ahead ledger → grade against your goals → route.

• Atlas—the live asset graph of everything you own, with blast-radius queries: what does this machine touch, what breaks if it's compromised.

• Ledger—change tracking, revived and extended estate-wide: versioning, the update registry, integrity gates, and per-deploy event capture. One system answers what changed, when, at what version, verified how, across the config tree and every deployed site and worker.

• Upgrades—the system-improvement queue. Improvement signals used to be fragmented across six stores with no lifecycle; now there's one queue fed by five sources, with a recommended-to-applied lifecycle linked to Ledger.

Versioning itself became autonomic in the same window: a deterministic drift nag at prompt time, manual-bump guards in all four component bumpers, and graded classification so a docs edit can't masquerade as a breaking change.

New skills

• ThreatModel—defensive threat modeling for your own estate: map where sensitive data lives across your asset graph, run compromise scenarios, and maintain a persistent risk register with likelihood×impact scoring. Code only; your real data stays in your private tree.

• DetectAI—detects AI-generated writing two ways: a heuristic audit against a catalog of known AI writing patterns, and an empirical detection score calibrated against known-human baselines.

• Tldraw—read, create, and edit tldraw canvas files deterministically: sketch hand-drawn-register diagrams straight into a file, or read a rough whiteboard back as structured data.

Install experience

The installer gained a capability doctor: it probes every external tool the doctrine assumes, fails loud on anything missing, and shows live/broken/declined capability states with fix commands, so a degraded install tells you it's degraded up front. Fresh keyless installs run clean through the writing gate, large-system-prompt spawns clear the OS argument limit, and hooks reconcile at install time.

Community

Two triage waves landed in this cycle: 18 ported fixes in one and a 40-PR port wave in the other, covering Pulse spawn races, Linux voice volume, TELOS parsing, systemd backends for Linux, and more. Every community fix gets ported into source and credited, so the next release ships it.

Release-security hardening

The release pipeline gained new deterministic gates this cycle, several born from adversarial audit findings: an offensive-security gate, a sanitizer-residue gate (half-scrubbed template tokens can never ship), a licensed-font gate (this release also removes previously-shipped commercially licensed fonts), a dead-legacy-doc-pointer gate, a gate blocking harness runtime state at the payload root, and closure of an edit-only permission bypass.

Install

curl -fsSL https://ourlifeos.ai/install.sh | bash

The system now knows what's installed—and says so.

🎥 Release video

Full-resolution download: LifeOS-7.0.0-Release-Video.mp4 (2:03) — this release builds on the 7.0.0 foundation.

Install awareness

LifeOS doctrine leans on external tools the core install doesn't ship: a cross-vendor audit CLI, a real browser for web verification, Cloudflare for scheduled flows, ElevenLabs for voice. Before 7.1.1, a missing tool failed silently. Now the system knows what's actually available and says so.

• Doctor — bun LIFEOS/TOOLS/Doctor.ts prints one line per capability: live ✅, broken ❌ with its own copy-paste fix command, or off ⏸. --network adds end-to-end auth checks. --reconcile catches hooks that exist on disk but never got registered in settings.
• Decline is a first-class answer — Doctor.ts decline <name> turns a capability off permanently and silently. No warnings, no red marks, no nagging. Running LifeOS without voice or without Cloudflare is a supported configuration, not a defect.
• The install asks — new step in INSTALL.md: after Core lands, the installer probes each capability and asks now, later, or never. Your choice is recorded.
• Failure-aware nudges — when a command fails because a capability is broken, you get one line with the exact fix command, then an hour of quiet.
• System Health in Pulse — the hooks page shows each capability's state, fix command, and heartbeat.

Installer overhaul

• GETTING-STARTED.md — new post-install guide shipped beside INSTALL.md: what each external tool powers, how to set it up, and how to prove it's live.
• InstallSettings.ts — settings placement is now a deterministic tool instead of a copy-by-hand step. It expands $HOME in env values at write time (the harness injects them verbatim, so a literal $HOME/ was silently creating a shadow directory that captured runtime state — the #1404/#1451 bug class), merges additively without touching existing values, dry-runs by default, and backs up before every write.
• Two-layer install model — INSTALL.md now presents Core (the skill, the full skill library, the runtime, the USER tree, the system prompt and its lifeos launch command) as one consent, with hooks/statusline/Pulse/agents as clearly-marked enhancements on top.
• The lifeos launch command matters and the docs now say why — the constitutional layer only loads when the harness launches with the system prompt appended. Plain claude gives you CLAUDE.md but not the constitution.
• install.sh resolves the latest release dynamically — no more pinned version in the bootstrap.
• Locale-aware units — the installer suggests the statusline temperature unit that matches your locale (#1456).

Runtime and tooling

• Algorithm v8.4.0 — plain-language depth steering ("go heavy", "quick pass") registers even before a run is open; claim wording sharpened; every nudge bounded to a single line.
• Statusline, rebuilt in three places — a live AGENTS roster with per-slot model readout and a cross-vendor slot; HOME resolution hardened to fail closed (#1463); a richer usage readout with per-model window and credit state.
• CarrierProbe.ts — new shipped tool that verifies which model actually executes your agent dispatches, end-to-end with transcript evidence, and fails stale facts after 30 days. Model-routing claims stop being folklore.
• Telegram hang fix — a stream that stopped yielding could hang the reply handler indefinitely (observed: one query ran 2.87 hours frozen on a partial reply). The timeout now actually aborts the stream and ships the partial text.
• Telos backup pruning — TELOS file backups keep a rolling window of the 3 newest per file instead of accumulating forever.
• Clean template voices — the shipped researcher agents and voice roster now default to ElevenLabs premade voices.
• Intro video in the README — the 2:03 walkthrough is embedded above the intro now.

Fixes

• USMetrics: EIA gas-price series and dollar-scale formatting (#1470 — thanks @HotSauceHacker)
• BitterPillEngineering: dead routing references repointed to the current routing table (#1471 — thanks @justinkatz94-glitch)
• FormatGate: observation-only, no more duplicated output on re-emit
• Fork-patch note in MemoryTypes (#1450)
• Doc de-staling across the tree: Router retirement propagated, Ledger doc slimmed, freshness stamps added

Install

Same as 7.0.0: give it to your AI. Tell it: "Read https://ourlifeos.ai/install and install LifeOS for me." It does the whole setup — detects your harness, wires hooks with your permission, scaffolds your files. Needs Claude Code + bun.

The Bitter Pill Release — stop over-instructing the model and let it think.

🎥 Release video

Full-resolution download: LifeOS-7.0.0-Release-Video.mp4 (2:03)

The biggest philosophical shift in LifeOS since it started: a year of added structure (modes, tiers, phase ceremonies, self-scores) swept back out. A capable model, given a clear "done" and good tools, thinks better without a rulebook.

What's new

• Bitter Pill Engineering — every instruction faced one test: would a smarter model make this rule unnecessary? If yes, it was cut. Kept the kernel: evidence-based verification, the ISA contract, safety gates, exact tool recipes.
• ~⅔ less always-on context — the every-turn doctrine went from ~88KB to ~28KB. Rationale and history moved to on-demand files. Faster, sharper on every turn.
• Modes and tiers are gone — no MINIMAL/NATIVE/ALGORITHM mode, no E1–E5 tier. One adaptive format, one loop; spend is discovered from the work, not a label.
• The Algorithm (v8.3.0) — the ISA is both hill and instrument: "done" stated as falsifiable claims, each naming the probe that refutes it. No claim closes without evidence.
• AlgorithmNudge — one deterministic sub-20ms nudge layer (skill routing + ISA freshness + spend), replacing several scattered hooks.
• Hook layer consolidated — ~16 hooks folded into per-event dispatchers. Fewer processes, same enforcement.
• Community fixes — work-events replay race, DA-name de-hardcoding, config-driven Pulse identity, voice-summary toggle, absolute-path binary resolution. Thanks to the contributors.

Install

Give it to your AI. Tell it: "Read https://ourlifeos.ai/install and install LifeOS for me." It does the whole setup — detects your harness, wires hooks with your permission, scaffolds your files. Needs Claude Code + bun.

LifeOS 6.0.5

The LifeOS rename lands in the code — plus a new Harvest skill.

LifeOS 6.0.5 is a maintenance release that carries the PAI→LifeOS rename the rest of the way through the system, adds the new Harvest skill, and sharpens the Algorithm's verification doctrine. Same system as 6.0.0, cleaner throughout.

What's new

The rename reaches the code

6.0.0 renamed the project. 6.0.5 renames the code — class-by-class, deliberately. Code identifiers and documentation prose now read "LifeOS" throughout, while behavioral code (paths, regexes, labels the system depends on at runtime) was left byte-identical on purpose. A blind find-and-replace across running code is how you corrupt a working system; the rename was scoped so the prose is clean and nothing breaks.

New skill — Harvest

Harvest mines a single piece of content — a URL, a YouTube video, an article, raw text — for anything genuinely useful to your LifeOS, judged against your whole system. It fetches the content, pulls out candidate ideas and techniques, tags each with a prior status (new / partial / done), ranks by usefulness, and reports where each one maps. It's report-only: adopting anything is always a separate, explicit step.

Algorithm v6.24.0 — motion gets verified

Verification doctrine gains one clause: an ISC whose subject is motion — an animation, a transition, a drag, a multi-step flow — now closes only on a frame-scrub gallery, never a single screenshot. One still can't capture motion, so the doctrine stops pretending it can. Static renders still close on one screenshot; the rule is keyword-triggered so it doesn't tax every task.

Installer fix

The bootstrap install.sh pinned the wrong release tarball. It now fetches the version it advertises. If you install from the one-liner, you get 6.0.5.

What's different from 6.0.0

Everything 6.0.0 introduced is still here: one self-contained skill, install-by-prompt, full Pulse on first boot, the seven-phase Algorithm, the ISA primitive, structured memory. This release refines; it doesn't change what the system is.

Install

Give it to your AI. Paste this into Claude Code and say "install this" — your AI does the whole setup.

curl -fsSL https://ourlifeos.ai/install.sh | bash

Prefer the terminal? Run the same command yourself. You'll need Claude Code and bun.

Upgrading

Back up first — cp -r ~/.claude ~/.claude-backup-$(date +%Y%m%d) — then install. Your USER/ customizations are never touched, and settings merge rather than overwrite.

LifeOS 6.0.3 — the install doc is now comprehensive and the constitution wires itself.

Install — hand it to your AI:

Read https://ourlifeos.ai/install and install LifeOS for me.

Terminal shortcut (Claude Code, macOS/Linux): curl -fsSL https://ourlifeos.ai/install.sh | bash

• Comprehensive component menu — INSTALL.md now lays out the full two-tier model: Core (skill + ~50-skill library + runtime + system prompt) plus à-la-carte enhancements (hooks, statusline, tooltips, spinner verbs, agents, Pulse, background jobs) — install all or pick a subset.
• The launch command — a new install step wires a lifeos shell alias that launches Claude with --append-system-prompt-file LIFEOS_SYSTEM_PROMPT.md, so the constitutional layer actually loads (plain claude stays vanilla).
• ourlifeos.ai/install renders the same canonical INSTALL.md as a clean page for humans and raw markdown for AIs — one source, updated in one place.
• Security-clean: 15/15 release gates + emit-time contract/staleness/payload gates + independent leak scan.

LifeOS 6.0.2 — skill-only distribution with an AI-native, .md-first install.

Install — hand it to your AI:

Read https://ourlifeos.ai/install and install LifeOS for me.

Terminal shortcut (Claude Code, macOS/Linux):

curl -fsSL https://ourlifeos.ai/install.sh | bash

• The whole system ships as one self-contained LifeOS/ skill (orchestrator + full install payload).
• ourlifeos.ai/install serves the AI-paste install doc; the shipped install.sh pins v6.0.2 and points at danielmiessler/LifeOS.
• Security-clean by construction: 15/15 release gates + emit-time contract/staleness/payload gates + a cross-vendor audit before publish.

LifeOS 6.0.0

The first release under the LifeOS name — and the whole system now ships as one self-contained skill.

LifeOS is a Life Operating System. It knows your goals, the people who matter to you, and where you are right now, and it works to move you toward where you want to be. The engine underneath is a verifiable loop: turn any request into testable criteria, then climb until they pass.

This is the first release under the LifeOS name. The project was called PAI (Personal AI Infrastructure). Everything you had is still here — this version adds a cleaner way to install it.

One-line install

curl -fsSL https://ourlifeos.ai/install.sh | bash

LifeOS is AI-native — it installs into your AI coding harness. Run the one-liner in your terminal, or paste it to your AI (Claude Code) and say "install this." It pulls the LifeOS skill from GitHub, drops it into your harness, then hands off to /lifeos-setup — a setup conversation with your AI that captures your goals and wires everything with your permission. Your AI does the install for you.

That command lays down the entire system:

• The system prompt and the operating rules
• The Algorithm — the loop that turns a request into criteria you can check, and keeps going until they hold
• 49 skills
• The hook system
• Pulse, your Life Dashboard, including the observability view
• The statusline, the memory scaffold, and a USER template you fill in with your own goals and context

What you need

• Claude Code
• bun

Notes

• The whole system ships as a single self-contained skill (LifeOS/). One directory, one install.
• Nothing personal ships. The USER tree is a blank template you populate; the download is clean.
• Pulse comes up empty on a fresh install and fills in as you run the setup interview.
• New name, same system. If you ran PAI, this is the next version of it.

Full changelog

See the commit history for the detail behind this release.

PAI v5.0.0 — Life Operating System

The biggest release in PAI history. PAI is no longer "AI scaffolding" — it is a Life Operating System with a unified daemon, a Life Dashboard, a personalized Digital Assistant, and a fully-articulated execution algorithm.

📚 Full documentation lives at docs.ourpai.ai — every subsystem (Algorithm, ISA, Memory, Skills, Hooks, Pulse, Containment) has its own deep-dive page with diagrams, examples, and reference material.

One-Line Install

curl -sSL https://ourpai.ai/install.sh | bash

That's it. The installer wizard handles Bun, Git, Claude Code verification, ElevenLabs key (optional), DA identity setup, voice picker, Pulse launchd registration, and validation. Existing ~/.claude/ is auto-backed-up to ~/.claude.backup-{TIMESTAMP} before anything is overwritten.

Prefer to inspect first? Read the script before piping it. Or clone manually:

git clone https://github.com/danielmiessler/PAI.git ~/.claude
cd ~/.claude && ./install.sh

After install:

open http://localhost:31337    # the Life Dashboard

TL;DR

Stop thinking of PAI as a Claude Code config. PAI is the framework that turns AI from a chatbot you talk to into a system that runs your life — it knows your goals, your people, your workflows, your current state, your ideal state, and continuously hill-climbs you from one to the other.

• PAI = Personal AI Infrastructure = the Life Operating System
• Your DA = your Digital Assistant = the primary interface to the OS (you name it)
• Pulse = the Life Dashboard + central daemon (port 31337)
• The Algorithm = the universal Current State → Ideal State execution loop

If you're upgrading from v4.x, this is a different system, not a patch. Read the Migration Guide before installing.

The Core Shift — Your DA is the center of your AI universe

PAI v4.x was scaffolding for AI. PAI v5.0.0 is the Life Operating System — and the way you experience that OS is one named DA.

We've spent the last few years arguing about agents and harnesses and context engineering and prompt engineering. Those are all real, and PAI runs every one of them inside it. But none of them are the point. The point is the single named entity with full context about your life — the conduit, the friend, the trusted assistant who knows everything about you and works on your behalf 24/7.

The principal — you, the human — is at the center. Your DA wraps around you. Skills, memory, the algorithm, hooks, agents, Pulse, the web, devices, robots, other people's DAs — all of it is infrastructure your DA reaches into. You don't talk to an army of agents. You talk to one entity. That entity has the army.

The prime directive is simple: read your current state from every signal it can reach, compare it to your TELOS-articulated ideal state, and constantly close the gap. That is what AI is for. That is what we are building.

Daniel walks through the full thesis in We're All Building a Single Digital Assistant — blog post + companion video. v5.0.0 is the implementation of the architecture argued for in that piece.

The Life OS thesis is canonical inside the repo as well: PAI/DOCUMENTATION/LifeOs/LifeOsThesis.md.

What changed in v5.0.0 — in priority order

The release is large. If you only read four bullets, read these:

1. The OS transition. PAI is now a Life Operating System with your DA at the center. The framing change is bigger than any individual feature.
2. PRD → ISA migration. Every project, task, and decision now articulates its Ideal State Artifact — one document, twelve sections, five identities. This replaces the old ad-hoc PRD pattern across the entire system.
3. Pulse — the unified daemon. One bun process, one port (31337), one launchd service, one log file. Replaces every loose voice/observability/hook script from v4.x.
4. 45 skills shipped — the most ever. Up from 36 leaf skills in v4.0.3 and 41 in v3.0. Catalog with descriptions and use cases below.

Plus a new constitutional layer: v5.0.0 adds a top-level system prompt (PAI/PAI_SYSTEM_PROMPT.md) loaded via --append-system-prompt-file, which encodes the non-negotiable behavioral rules — output format, verification doctrine, security protocol — at the highest priority above CLAUDE.md. Adherence is dramatically stronger than v4.x.

Headline Changes

1. Pulse — the unified daemon (THE big new component)

PAI/PULSE/pulse.ts — one bun process, one port (31337), one launchd plist, one log file.

Pulse replaces every previous loose service. It runs:

• Voice notifications via ElevenLabs (/notify endpoint)
• Hook execution for the entire PAI lifecycle (SessionStart, PreToolUse, PostToolUse, Stop, PreCompact, etc.)
• Observability — tool activity, failures, satisfaction signals, Algorithm reflections
• Performance monitoring
• Syslog capture (UniFi, etc.)
• Cron scheduling for routines and recurring jobs
• The Life Dashboard at http://localhost:31337 — Next.js app served from Observability/out/
• Wiki API — exposes your KNOWLEDGE archive + system docs over HTTP
• Optional integrations — Telegram bot, iMessage bridge, DA messaging

After install, Pulse runs as a supervised macOS launchd service (com.pai.pulse) with a menu bar app. You should leave it running. It's how your DA reaches you with voice, how the dashboard stays live, how scheduled work fires.

The dashboard surfaces 22 routes: Life, Health, Finances, Business, Work, Telos, Goals, Air, Performance, Hooks, Skills, Agents, Security, Knowledge, Knowledge Graph, System Docs, System Graph, Arbol, Ladder, Novelty, Assistant, root.

2. The DA system — your AI gets a name

Every PAI install picks a DA identity: name, voice, color, personality. This is your AI — the peer you work with daily. The reference implementation ships with a generic "PAI" DA on free ElevenLabs public voices so you can hear it work out of the box. Run /interview after install and your DA will guide you through naming itself, picking a voice, capturing your TELOS.

Both files are loaded at session start so the DA always has them in context. The Life OS frame requires this — without the DA knowing who you are, none of the upstream features have anything to climb against.

3. The Algorithm v6.3.0 — Current State → Ideal State, formalized

PAI/ALGORITHM/v6.3.0.md is doctrine. Every non-trivial task runs through the seven phases: OBSERVE → THINK → PLAN → BUILD → EXECUTE → VERIFY → LEARN. The Algorithm is the centerpiece of PAI — everything else feeds it.

What's new in v6.x:

• Mode classifier — a Sonnet-backed UserPromptSubmit hook decides MINIMAL / NATIVE / ALGORITHM and tier (E1–E5) for every prompt. The executor obeys the classifier; no regex layer, no model judgment.
• Closed-list thinking capabilities — IterativeDepth, ApertureOscillation, FirstPrinciples, SystemsThinking, RootCauseAnalysis, Council, RedTeam, Science, BeCreative, Ideate, BitterPillEngineering, Evals, WorldThreatModel, Fabric patterns, ContextSearch, ISA, Advisor, ReReadCheck, FeedbackMemoryConsult. Phantom capabilities (anything outside this list) are a CRITICAL FAILURE.
• Effort tiers — E1 (<90s) through E5 (<2h+). Time budget is the hard constraint; thinking-floor and ISC-count are tier-graded.
• Voice phase announcements — every phase transition narrates over Pulse so you can follow long tasks audibly.
• Verification doctrine — live-probe required for user-facing artifacts, advisor calls at commitment boundaries, Cato cross-vendor audit at E4/E5, conflict surfacing on advisor/empirical contradictions.

4. The ISA — the universal "ideal state" primitive (PRD → ISA migration)

This is the second-biggest shift in v5.0.0. The Ideal State Artifact replaces the PRD as the unit of work across PAI.

Old PRDs were task-shaped: a description of a thing to build, separate from how you'd verify it, separate from where the build's truth lived. The ISA collapses all of that into one document with five identities at once:

• Ideal state articulation — what "done" actually looks like, as a hard-to-vary explanation (David Deutsch)
• Test harness — the criteria are the tests, with named tool probes for each
• Build verification — passing the criteria verifies what was built
• Done condition — task complete when every criterion passes
• System of record — the canonical truth for the thing being articulated

12 fixed sections, in order: Problem → Vision → Out of Scope → Principles → Constraints → Goal → Criteria → Test Strategy → Features → Decisions → Changelog → Verification. Required sections per effort tier are HARD-gated (E1: Goal+Criteria; E4/E5: all twelve).

Two homes:

• Project ISAs live with the project — <project>/ISA.md — for any thing with persistent identity (an app, a CLI tool, a library, a content pipeline). Iteration on the project IS iteration on this ISA.
• Task ISAs live at MEMORY/WORK/{slug}/ISA.md — for one-shot tasks that don't belong to a persistent thing.

The ISA skill at skills/ISA/ owns six workflows — Scaffold, Interview, CheckCompleteness, Reconcile, Seed, Append — with a dozen reference examples spanning E1–E5 across code, art, design, ops, marketplace, and enterprise. The skill enforces ID-stability (ISCs never re-number on edit; splits become ISC-N.M; drops become tombstones), the conjecture/refutation/learning Changelog format, and the per-tier completeness gate.

If you took one thing from v5.0.0, this is the bigger half of it. The other half is the OS framing.

5. Containment + release tooling — privacy is structural

PAI's privacy boundary is now enforced at the file system level, not by hand-maintained allowlists.

• hooks/lib/containment-zones.ts — TypeScript module that declares every directory's privacy zone. Single source of truth for both prospective and retrospective enforcement.
• hooks/ContainmentGuard.hook.ts (PreToolUse) — blocks any Write/Edit/MultiEdit that would land sensitive content outside its zone.
• skills/_PAI/Tools/ShadowRelease.ts — public-release builder. Runs 12 security gates (G1 zone deletion, G2 identity grep, G3 Cloudflare ID grep, G4 trufflehog, G5 .env strays, G6 private tokens, G7 reference integrity, G8 private skill refs, G9 username paths, G10 staging boot, G11 dashboard leak, G12 template-only USER/MEMORY). Build fails closed.
• Two-stage release — Stage 1 stages to ~/.claude/PAI/PAI_RELEASES/{VERSION}/.claude/ with all 12 gates. Stage 2 publishes to GitHub. The two never auto-chain.

6. The Skills system — 45 public skills, 171 workflows

Skills are self-activating composable domain units. Your DA selects them at runtime based on intent. The public release ships 45 skills (private skills with _ALLCAPS names stay in your install).

This is the most skills any PAI release has ever shipped. For reference: v3.0 shipped 41 flat skills, v4.0.3 shipped 36 leaf skills (47 SKILL.md files counting category wrappers). v5.0.0 ships 45 individual top-level skills, every one independently invocable.

Below is the complete catalog — what each skill does, and how we actually use it day-to-day.

7. The Memory system v7.6 — compounding by design

Memory is structured by purpose, not by chronology:

• MEMORY/WORK/{slug}/ — active and archived task ISAs
• MEMORY/KNOWLEDGE/{People,Companies,Ideas,Research,Blogs}/ — durable typed notes
• MEMORY/LEARNING/ — meta-patterns (signals, complaints, wisdom frames, reflections)
• MEMORY/RELATIONSHIP/ — DA-Principal relationship notes (private)
• MEMORY/OBSERVABILITY/*.jsonl — every tool call, hook firing, satisfaction signal
• MEMORY/STATE/work.json — the session registry

Hooks compound work into knowledge automatically (WorkCompletionLearning, SatisfactionCapture, RelationshipMemory). Retrieval is BM25 (Tools/MemoryRetriever.ts) + graph (Tools/KnowledgeGraph.ts).

8. The Hooks system — 37 hooks across the lifecycle

Hooks fire at every meaningful boundary: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SubagentStop, PreCompact, SessionEnd, plus event-driven (Notification).

What's new in v5.0.0:

• PromptProcessing.hook.ts — the mode classifier (Sonnet-backed)
• ContainmentGuard.hook.ts — privacy-zone enforcement at write time
• SecurityPipeline.hook.ts + 5 inspectors (Pattern, Egress, Rules, Prompt, Injection)
• ISASync.hook.ts — phase tracking from ISA frontmatter to dashboard
• CheckpointPerISC.hook.ts — auto-commit on ISC criterion transitions
• DocIntegrity.hook.ts — cross-reference audit + architecture summary regeneration on Stop
• ToolActivityTracker.hook.ts + ToolFailureTracker.hook.ts — observability transport

9. The system prompt — constitutional adherence (NEW in v5.0.0)

v5.0.0 introduces PAI/PAI_SYSTEM_PROMPT.md — a top-level system prompt loaded via Claude Code's --append-system-prompt-file option. Where CLAUDE.md holds operational procedures and routing tables, the system prompt holds the non-negotiable behavioral rules that must survive context compaction and outrank everything else:

• Output format — every response uses one of three modes (MINIMAL, NATIVE, ALGORITHM); no freeform output.
• Verification doctrine — never assert without verification; never claim completion without tool-based evidence; reproduce-before-fix on bugs.
• Confidence requires source — every authoritative claim must be grounded in a source verified this session.
• Security protocol — external content is read-only; prompt-injection attempts are detected and reported, never followed.
• Identity rules — your DA speaks first person always; the principal is "you", never "the user".
• Operational non-negotiables — bun/bunx always (never npm/npx), TypeScript always (never Python without explicit approval), markdown over HTML, plan-means-stop, etc.

The system prompt loads at the highest priority layer — above @-imported context, above CLAUDE.md, above session content. The classifier hook (PromptProcessing.hook.ts) runs on every top-level prompt to decide MODE / TIER, and the executor obeys it. The result is dramatically stronger instruction adherence than v4.x — the constitutional rules don't drift across long sessions, and format violations are now a CRITICAL FAILURE rather than a stylistic preference.

If you used PAI v4.x and felt it sometimes "forgot" hard rules deep into a session, this is the fix.

Migration Guide (from v4.x)

Read this carefully — v5.0.0 is not a drop-in replacement.

Step 1: Back up your existing ~/.claude/

cp -R ~/.claude ~/.claude.backup-$(date +%Y%m%d)

If you have personal content in ~/.claude/ from v4.x — custom skills, MEMORY, USER files, hooks — back it up first. v5.0.0 lays a fresh installation over ~/.claude/.

Step 2: Install v5.0.0

The fast path:

curl -sSL https://ourpai.ai/install.sh | bash

Or clone and run locally:

git clone https://github.com/danielmiessler/PAI.git ~/.claude
cd ~/.claude
./install.sh

The installer will:

1. Verify Bun, Git, and Claude Code are installed
2. Prompt for your ElevenLabs API key (skippable — voice falls back to desktop notifications)
3. Launch a web wizard for DA identity (name + voice + personality)
4. Set up Pulse as a launchd service
5. Run validation

Step 3: Personalize your DA

Run /interview in Claude Code. Your DA will guide you through:

1. Phase 1 — TELOS: Mission, Goals, Beliefs, Wisdom, Challenges, Books, Wrong-beliefs, Mental models, Narratives
2. Phase 2 — IDEAL_STATE: What does success look like for you?
3. Phase 3 — Preferences: Tools, conventions, working style
4. Phase 4 — Identity: Final DA personality tuning

This is the most important step. Without TELOS, your DA has nothing to optimize against.

Step 4: Migrate your content into PAI/USER/

If you had personal content in v4.x (notes, project state, custom rules), have your DA help you migrate it.

Tell your DA: "Help me migrate my old content into the PAI/USER/ structure."

Your DA will use the Migrate skill, which:

• Intakes content from .md/.markdown/.txt, stdin, Obsidian, Notion, Apple Notes
• Classifies each chunk against the PAI destination taxonomy (TELOS, KNOWLEDGE, PROJECTS, FEED, etc.)
• Asks you to approve each placement
• Commits with provenance metadata

Common migration targets:

Step 5: Open the Life Dashboard

open http://localhost:31337

The dashboard surfaces every aspect of your Life OS. Use it daily. It is the visible surface — the place to stay updated on everything happening in your life.

Step 6: Add your content sources to FEED.md

Edit PAI/USER/FEED.md to add the YouTube channels, blogs, newsletters, X accounts, podcasts, and RSS feeds you want PAI to monitor on your behalf. The Feed system polls them, parses them, and surfaces what matters.

Step 7: Verify everything is running

# Pulse should be alive
curl -s http://localhost:31337/api/pulse/health | jq

# Voice should announce
curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello from your DA"}'

# The dashboard should render
open http://localhost:31337

What's Different from v4.x (Breaking Changes)

• Skill paths — flat skills/Foo/ (was nested skills/Category/Foo/ in v4.x)
• Algorithm — v6.3.0 is doctrinally different from v3.6.0 (12-section ISA, closed-list capabilities, mode classifier)
• Pulse replaces — every loose voice/observability/hook script from v4.x is now consolidated into pulse.ts
• USER vs MEMORY split — USER/ is your durable identity + goals; MEMORY/ is operational state + knowledge graph. v4.x mixed these.
• Containment zones — your private content has structural protection now. If you try to write to a public area with private patterns, the ContainmentGuard hook blocks it.
• DA Identity is mandatory — v4.x had implicit identity; v5.0.0 requires DA_IDENTITY.md to be populated for the DA to function with the Life OS frame.

Documentation

Acknowledgements

The v5.0.0 release reflects months of architecture work — collapsing scattered scripts into Pulse, formalizing the Algorithm's seven phases, building the ISA primitive, and articulating the Life OS thesis. Thanks to everyone who filed PRs, reported issues, and tested experimental builds.

If you're new to PAI, start with the Life OS Thesis. If you're upgrading from v4.x, follow the Migration Guide. Either way, let your DA do the heavy lifting — that's what they're for.

Released: 2026-04-30
Source commit: 9fa02cb00
Files in release: 1642 · Size: 58.9 MB · Gates: 12/12 ✅

4 community-contributed fixes — no new features, no breaking changes.

What Changed

Inference & Parsing

• #800 Inference.ts JSON parsing only matched objects {} — now handles arrays [] too, with validation via JSON.parse

Documentation & Portability

• #836 CONTEXT_ROUTING.md had 29 dead references to files removed in v4.0 — consolidated to 4 README pointers
• #817 WorldThreatModelHarness hardcoded ~/.claude/ path — now uses $PAI_DIR for portability

Installer

• #846 Upgrading from v2.5/v3.0 stranded user context at skills/PAI/USER/ — installer now migrates files to PAI/USER/ and creates symlinks for backwards compatibility

Installation

git clone https://github.com/danielmiessler/Personal_AI_Infrastructure.git
cd Personal_AI_Infrastructure/Releases/v4.0.3
cp -r .claude ~/ && cd ~/.claude && bash install.sh

See the Releases directory for all versions and upgrade instructions.

Contributors

Thank you to @rikitikitavi2012-debug, @spirotot, and @catchingknives for these contributions!