pipulate 2.71__tar.gz → 2.72__tar.gz

{pipulate-2.71 → pipulate-2.72}/.agents/skills/journal/references/index.md

@@ -2,7 +2,7 @@
 
 > Auto-generated on 2026-09-29 by `scripts/articles/generate_ai_context.py` and
 > rewritten from scratch on every release. If this date looks stale, assume
-> the rest of the repo is newer than this map. 1503 entries indexed.
+> the rest of the repo is newer than this map. 1504 entries indexed.
 
 This repository holds the *machinery*. The *reasoning*, the running journal
 that explains why every piece exists, lives on a separate website and not in
@@ -27,6 +27,7 @@ The first 20 entries include full `index.md` URLs to establish
 the link pattern. All remaining entries are bare slugs. Reconstruct any full
 URL as: `https://mikelev.in/futureproof/{slug}/index.md`
 
+- [2026-09-29] [The Three-Door Installer: Named Prompts, Split DNS, and Verifiable Releases](https://mikelev.in/futureproof/the-three-door-installer-and-named-prompts/index.md)
 - [2026-09-29] [The Deed Is Named for the Door: Engineering Replayable QA Archives for AI](https://mikelev.in/futureproof/the-deed-is-named-for-the-door-qa-archive-zip/index.md)
 - [2026-09-29] [The Qamy Door and the Cellular Witness: Launching a Third Domain with Replayable Receipts](https://mikelev.in/futureproof/qamy-door-cellular-witness-replayable-receipts/index.md)
 - [2026-09-28] [The Forward-Slash Test: Bridging Agent Skills to Claude Code with Verifiable Receipts](https://mikelev.in/futureproof/the-forward-slash-test-claude-skills-bridge/index.md)
@@ -46,12 +47,12 @@ URL as: `https://mikelev.in/futureproof/{slug}/index.md`
 - [2026-09-19] [Playing Pinball in the Age of AI: A Replayable Workflow Guide](https://mikelev.in/futureproof/playing-pinball-in-the-age-of-ai-replayable-workflow-guide/index.md)
 - [2026-09-19] [The Color Blue and the Pipe: Inspecting Code Before Execution](https://mikelev.in/futureproof/color-blue-pipe-inspecting-code/index.md)
 - [2026-09-19] [Edna Mode Rules for AI Workflows: Why Practical Tooling Beats Fragile Abstractions](https://mikelev.in/futureproof/edna-mode-rules-for-ai-workflows/index.md)
-- [2026-09-18] [The One-Door Threshold: Engineering Replayable AI Workflows and Quiet Shells](https://mikelev.in/futureproof/the-one-door-threshold-replayable-ai-workflows/index.md)
 
-## Compact slug index — pattern: https://mikelev.in/futureproof/{slug}/index.md
+## Compact slug index -- pattern: https://mikelev.in/futureproof/{slug}/index.md
 
-Format: `[date] [size] slug` — fetch any entry as `https://mikelev.in/futureproof/{slug}/index.md`
+Format: `[date] [size] slug` -- fetch any entry as `https://mikelev.in/futureproof/{slug}/index.md`
 
+- [2026-09-18] [207k] the-one-door-threshold-replayable-ai-workflows
 - [2026-09-18] [292k] the-first-ten-minutes-reproducible-ai-workflows
 - [2026-09-17] [184k] retrieval-cue-memory-consolidation-selective-hydration
 - [2026-09-17] [239k] the-voice-asks-first-verifiable-consent

{pipulate-2.71 → pipulate-2.72}/AGENTS.md

@@ -1,4 +1,4 @@
-# AGENTS.md — Pipulate
+# AGENTS.md -- Pipulate
 
 This repository carries Agent Skills under https://agentskills.io/specification
 (`.agents/skills/*/SKILL.md`, a YAML head over a Markdown body, loaded on
@@ -16,24 +16,24 @@ that duplicates code will drift and is a bug.
 
 ## Setup (the executable version of "Dev environment tips")
 
-- `nix develop` — the full environment. On a terminal it stops at a short
+- `nix develop` -- the full environment. On a terminal it stops at a short
   list of words and a `(nix)` prompt with nothing started; `jn` starts
   JupyterLab and the server. Without a terminal it starts the app, so an
   agent takes the quiet shell below. See `flake.nix`.
-- `nix develop .#quiet` — minimal shell for agents and scripting.
+- `nix develop .#quiet` -- minimal shell for agents and scripting.
 - Python lives in `.venv/`; invoke as `.venv/bin/python`.
 
 ## Workspace (the layout `nix develop` materializes under `Workshop/`)
 
 `Workshop/` is JupyterLab's root, not Pipulate's: three folders, corporate/, personal/ and shared/, and nothing else, with the starter notebooks under personal/Notebooks/. The tree below is GENERATED
 between the sentinel comments by `prompt_foo.py` from the sealed `workspace_tree`
-figurate asset — do not hand-edit it; edit the asset in
+figurate asset -- do not hand-edit it; edit the asset in
 `imports/ascii_displays.py` and recompile. Empty here means the compiler has not
 run since the sentinels landed.
 
 <!-- --- START WORKSPACE TREE --- -->
 ```text
-   Workshop/   — the JupyterLab root (NOT Pipulate's own root)
+   Workshop/   -- the JupyterLab root (NOT Pipulate's own root)
    │            FLAT siblings. Nothing nests. Nothing to get wrong.
    │
    ├── corporate/              the org's canon · gitignored · its own private repo
@@ -69,5 +69,5 @@ run since the sentinels landed.
 - Propose changes as SEARCH/REPLACE blocks (exact-match, `[[[SEARCH]]]` /
   `[[[DIVIDER]]]` / `[[[REPLACE]]]`) applied via `cat patch | python apply.py`.
 - Never patch `.ipynb` directly; `nbstripout` and `jupytext` are in play
-  (see `.gitattributes`) — patch helper modules or give cell instructions.
+  (see `.gitattributes`) -- patch helper modules or give cell instructions.
 - Python edits are AST-checked and Nix edits are syntax-checked before write.

{pipulate-2.71 → pipulate-2.72}/AUDIT.md

@@ -62,8 +62,8 @@ any local desktop application:
 
 These borrow vocabulary from formal control catalogs without pretending to
 implement them. NIST SP 800-53 and the CIS Benchmarks are valuable here as a
-shared language — assets, trust boundaries, least privilege, auditability,
-credential lifecycle, update path, logging, recovery, configuration management —
+shared language -- assets, trust boundaries, least privilege, auditability,
+credential lifecycle, update path, logging, recovery, configuration management --
 not as a compliance checklist that a single-user desktop tool is obligated to
 satisfy line by line. This is an 80/20 hardening posture: make the obvious
 low-cost failures impossible, make the unavoidable risks visible, and make the
@@ -85,8 +85,8 @@ Every path in the system should belong to one of four classes:
 - Operator-configured paths, supplied explicitly and documented as host-specific.
 
 Human-facing examples may use `~/repos/...` for readability. Executable logic must
-resolve paths through a named accessor — repo root discovery, the workspace
-manifold, `$PIPULATE_ROOT`, or an explicit config value — rather than embedding
+resolve paths through a named accessor -- repo root discovery, the workspace
+manifold, `$PIPULATE_ROOT`, or an explicit config value -- rather than embedding
 `/home/<user>/...`. References to a separate local repository (for example a
 sibling publishing repo) are operator-configured paths and should be named as
 such, not treated as portable defaults.
@@ -147,7 +147,7 @@ explicit. A container's writable layer is ephemeral and does not survive the
 container being destroyed, so the following must be provided as mounted volumes or
 bind mounts for the tool to behave correctly: local database state, downloads,
 logs, notebooks, and any operator workspace and `.env`. The container story is
-therefore a state contract — these paths must be writable and persistent, these
+therefore a state contract -- these paths must be writable and persistent, these
 ports are exposed, these capabilities are not required, and these features degrade
 or disable when run in a constrained container context. Stated that way, "can I
 just use Docker?" becomes a supported compatibility output rather than an
@@ -235,8 +235,8 @@ to the review function on the same terms it is used here.
 
 The correct review of Pipulate is the review of a local-first, single-tenant,
 reproducible desktop-class tool with a browser-rendered UI. Audit it for its real
-risks — local port exposure, credential lifecycle, update provenance, filesystem
-writes, dependency freshness, cloud opt-ins, and recovery — and the hardening work
+risks -- local port exposure, credential lifecycle, update provenance, filesystem
+writes, dependency freshness, cloud opt-ins, and recovery -- and the hardening work
 described here is a translation layer between sovereign local computing and
 institutional risk language.
 

{pipulate-2.71 → pipulate-2.72}/MANIFEST.in

@@ -1,6 +1,6 @@
 # Work-in-progress plugin sketches (xx_ prefix) never ship to PyPI.
 # Runtime plugin discovery already skips xx_ files; this keeps the sdist
-# — and the wheel `python -m build` derives from it — in agreement with
+# -- and the wheel `python -m build` derives from it -- in agreement with
 # that convention. Fix protects v2.1 forward; the 2.0 artifact is history.
 exclude apps/xx_*.py
 

{pipulate-2.71 → pipulate-2.72}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pipulate
-Version: 2.71
-Summary: The context compiler that helps you prompt well — local-first, Nix-reproducible, replayable. The successor to AI SEO software.
+Version: 2.72
+Summary: The context compiler that helps you prompt well -- local-first, Nix-reproducible, replayable. The successor to AI SEO software.
 Author-email: Mike Levin <pipulate@gmail.com>
 License-Expression: AGPL-3.0-or-later
 Project-URL: Homepage, https://github.com/miklevin/pipulate/
@@ -137,7 +137,7 @@ nix develop
 ### Where your work lives
 <!-- --- START WORKSPACE TREE --- -->
 ```text
-   Workshop/   — the JupyterLab root (NOT Pipulate's own root)
+   Workshop/   -- the JupyterLab root (NOT Pipulate's own root)
    │            FLAT siblings. Nothing nests. Nothing to get wrong.
    │
    ├── corporate/              the org's canon · gitignored · its own private repo
@@ -185,13 +185,13 @@ nix develop
 
 ## AI On Rails: Structured Workflows for Any AI
 
-**The Challenge with Agentic AI:** Powerful but unpredictable—you never know what you're gonna get.
+**The Challenge with Agentic AI:** Powerful but unpredictable--you never know what you're gonna get.
 
-**The Pipulate Approach:** Structured workflows that can leverage **any AI**—local, cloud, or hybrid—while maintaining complete visibility and control.
+**The Pipulate Approach:** Structured workflows that can leverage **any AI**--local, cloud, or hybrid--while maintaining complete visibility and control.
 
 Think of it as putting guardrails on AI assistance. Instead of asking an AI to "figure it out," domain experts create step-by-step workflows that guide AI through proven processes. The AI gets structure, you get predictable results.
 
-**Pipulate: Your AI Swiss Army Knife:** Whether you prefer local privacy, cloud power, or hybrid approaches, Pipulate provides the framework. Use local models for sensitive work, cloud APIs for heavy lifting, or both in the same workflow—your choice, your control.
+**Pipulate: Your AI Swiss Army Knife:** Whether you prefer local privacy, cloud power, or hybrid approaches, Pipulate provides the framework. Use local models for sensitive work, cloud APIs for heavy lifting, or both in the same workflow--your choice, your control.
 
 ```text
       🤖 AGENTIC MODE (Chaos)           🚂 AI ON RAILS (Pipulate)
@@ -272,9 +272,9 @@ Pipulate is a **local-first, single-tenant desktop app framework** featuring AI-
 
 ### The Magnum Opus: Computing Sovereignty
 
-This isn't just another framework — it's a **deliberate culmination** of decades of tech evolution insights. Pipulate represents the "third act" approach to development (3rd time's the charm): choosing the **most durable and lovable** parts of the modern tech stack while rejecting the exhausting hamster wheel of framework churn.
+This isn't just another framework -- it's a **deliberate culmination** of decades of tech evolution insights. Pipulate represents the "third act" approach to development (3rd time's the charm): choosing the **most durable and lovable** parts of the modern tech stack while rejecting the exhausting hamster wheel of framework churn.
 
-If you are not an Empire builder and prefer craftsmanship over the rat race and want to build tools that last, then Pipulate may be for you. Pipulate embodies that philosophy — maximum creative freedom with minimum technical debt, recapturing *that old Webmaster feeling.*
+If you are not an Empire builder and prefer craftsmanship over the rat race and want to build tools that last, then Pipulate may be for you. Pipulate embodies that philosophy -- maximum creative freedom with minimum technical debt, recapturing *that old Webmaster feeling.*
 
 ### Core Philosophy: Local-First, WET, and AI-Augmented
 
@@ -307,8 +307,8 @@ If you are not an Empire builder and prefer craftsmanship over the rat race and
                                                
 ```
 
-- **Local-First Sovereignty:** Your data, code, and AI run on your hardware by default—extending to cloud services when you choose. This guarantees privacy, eliminates surprise costs, and gives you complete control over when and how to scale.
-- **WET Workflows, DRY Framework:** Workflows are intentionally "WET" (explicit & step-by-step) for maximum clarity and customizability—perfectly mirroring Jupyter Notebooks. The underlying framework is "DRY" for efficiency.
+- **Local-First Sovereignty:** Your data, code, and AI run on your hardware by default--extending to cloud services when you choose. This guarantees privacy, eliminates surprise costs, and gives you complete control over when and how to scale.
+- **WET Workflows, DRY Framework:** Workflows are intentionally "WET" (explicit & step-by-step) for maximum clarity and customizability--perfectly mirroring Jupyter Notebooks. The underlying framework is "DRY" for efficiency.
 
 - **The AI Advantage:** AI makes WET practical. Tedious code maintenance and refactoring, once a weakness of WET, is now an area where AI excels, turning repetition into a strength for rapid, context-aware development. Our breakthrough **Workflow Reconstruction System** exemplifies this: intelligent AST-based transplantation of workflow components eliminates traditional OOP inheritance complexity while maintaining perfect code precision.
 - **Radical Transparency ("Know EVERYTHING!"):** We reject opaque enterprise patterns in favor of complete observability. State is managed in transparent SQLite tables and JSON blobs, making the entire system intuitive and debuggable. No black boxes, ever.
@@ -401,7 +401,7 @@ Pipulate integrates a carefully selected set of tools aligned with its philosoph
        part of the system                         the entire system
 ```
 
-The original LAMP stack was beautiful in its simplicity — one person could understand and manage the whole stack. But it got bloated with enterprise patterns, microservices, and distributed complexity.
+The original LAMP stack was beautiful in its simplicity -- one person could understand and manage the whole stack. But it got bloated with enterprise patterns, microservices, and distributed complexity.
 
 Pipulate brings back that **"one person, full stack"** philosophy with modern tools:
 
@@ -410,7 +410,7 @@ Pipulate brings back that **"one person, full stack"** philosophy with modern to
 - **M**iniDataAPI: Universal SQL simplifier close to Python's core data structures
 - **P**ython + FastHTML + HTMX: The new web development paradigm
 
-This stack isn't just simpler—it's optimized for AI-assisted development. Here's why:
+This stack isn't just simpler--it's optimized for AI-assisted development. Here's why:
 
 * **Minimal Surface Area**: The AI doesn't waste time guessing about complex, out-of-context dependencies. More of the relevant code is directly readable and fits into a single prompt.
 * **Bedrock Dependencies**: The core components (Python, HTML, HTMX) change at a glacial pace, so they are already well-understood by base AI models, requiring no extra context.
@@ -440,7 +440,7 @@ Pipulate's technology choices form **aligned lenses** that focus ideas from abst
           AI Help
 ```
 
-We keep lenses minimal, their material either thoroughly pre-trained into the model (Python 3.x, HTMX, etc.) or able to be included in the prompt and easily held in the context window. We've trimmed the cruft — the lens flashes and burrs, and all unnecessary extra lenses (Angular, React, Vue, etc.)
+We keep lenses minimal, their material either thoroughly pre-trained into the model (Python 3.x, HTMX, etc.) or able to be included in the prompt and easily held in the context window. We've trimmed the cruft -- the lens flashes and burrs, and all unnecessary extra lenses (Angular, React, Vue, etc.)
 
 ```yaml
 HARDWARE:
@@ -463,7 +463,7 @@ APP:
 
 ### Grinding Off the Burrs and Flashes
 
-In lens manufacturing, "flashes" are excess material that squeeze out of molds — unwanted projections that must be ground off. Steve Jobs famously did this twice: adopting Gorilla Glass (grinding off plastic flashes) and rejecting Flash Player (grinding off software bloat).
+In lens manufacturing, "flashes" are excess material that squeeze out of molds -- unwanted projections that must be ground off. Steve Jobs famously did this twice: adopting Gorilla Glass (grinding off plastic flashes) and rejecting Flash Player (grinding off software bloat).
 
 **Pipulate continues this tradition:**
 - **FastHTML**: Grinds off Jinja2 template complexity
@@ -477,11 +477,11 @@ The result: clean, focused tools that do their job without unnecessary cruft.
 
 ## From Flask to FastAPI to FastHTML
 
-This is not your father's Python web framework. HTMX changes everything — a marriage made in heaven between Python and the Web, finally turning Python into a first-class citizen for web development. In many use cases such as this one, Python is even preferable to JavaScript in the way it blends Python's formidable ecosystem of packages with workflows.
+This is not your father's Python web framework. HTMX changes everything -- a marriage made in heaven between Python and the Web, finally turning Python into a first-class citizen for web development. In many use cases such as this one, Python is even preferable to JavaScript in the way it blends Python's formidable ecosystem of packages with workflows.
 
 ### The Evolution: Flask → FastAPI → FastHTML
 
-The revolution isn't just another framework — it's eliminating the template layer entirely:
+The revolution isn't just another framework -- it's eliminating the template layer entirely:
 
 ```text
     🍶 FLASK ERA              🚀 FASTAPI ERA            🌐 FASTHTML ERA
@@ -515,15 +515,15 @@ The revolution isn't just another framework — it's eliminating the template la
 
 **The FastHTML Breakthrough:** Python function names directly become HTML elements, eliminating templates and making the server the single source of truth for UI state.
 
-* **HTMX:** Enables dynamic, interactive UIs directly in HTML via attributes, minimizing the need for custom JavaScript. Pipulate uses it for server-rendered HTML updates — *over the wire HTML*-fragments targeting elements of the DOM directly instead of fragile, performance-reducing, framework-dependent JSON. *THIS* is where you *jump off the tech-churn hamsterwheel* and future-proof yourself.
+* **HTMX:** Enables dynamic, interactive UIs directly in HTML via attributes, minimizing the need for custom JavaScript. Pipulate uses it for server-rendered HTML updates -- *over the wire HTML*-fragments targeting elements of the DOM directly instead of fragile, performance-reducing, framework-dependent JSON. *THIS* is where you *jump off the tech-churn hamsterwheel* and future-proof yourself.
 
-* **MiniDataAPI:** A lightweight layer for interacting with SQLite and other databases. Uses Python dictionaries for schema definition, promoting type safety without the complexity of traditional ORMs — effectively future-proofing your SQL. You lose fancy *join* capabilities but in exchange get the *Python dict interface* as your main persistent database API forever-forward, enabiling instant swapability between SQLite and PostgreSQL (for example).
+* **MiniDataAPI:** A lightweight layer for interacting with SQLite and other databases. Uses Python dictionaries for schema definition, promoting type safety without the complexity of traditional ORMs -- effectively future-proofing your SQL. You lose fancy *join* capabilities but in exchange get the *Python dict interface* as your main persistent database API forever-forward, enabiling instant swapability between SQLite and PostgreSQL (for example).
 
-* **Ollama:** Facilitates running LLMs locally, enabling in-app chat, workflow guidance, and future automation capabilities while ensuring privacy and avoiding API costs. Your local AI (Chip O'Theseus) learns & grows with you, hopping from hardware to hardware as you upgrade — like a genie in a hermitcrab shell. And if that weren't kooky enough — it knows how to make MCP-calls!!! That's right, your friendly localhost AI Chip O'Theseus is also an *MCP client!* Your linear workflows ain't so linear anymore when a single-step can be: "Go out and do whatever."
+* **Ollama:** Facilitates running LLMs locally, enabling in-app chat, workflow guidance, and future automation capabilities while ensuring privacy and avoiding API costs. Your local AI (Chip O'Theseus) learns & grows with you, hopping from hardware to hardware as you upgrade -- like a genie in a hermitcrab shell. And if that weren't kooky enough -- it knows how to make MCP-calls!!! That's right, your friendly localhost AI Chip O'Theseus is also an *MCP client!* Your linear workflows ain't so linear anymore when a single-step can be: "Go out and do whatever."
 
 ### The Hybrid Advantage: Best of Both Worlds
 
-**Pipulate isn't anti-cloud—it's pro-choice.** Each workflow step can choose the best tool for the job:
+**Pipulate isn't anti-cloud--it's pro-choice.** Each workflow step can choose the best tool for the job:
 
 - **Step 1**: Use local AI for sensitive data analysis (privacy-first)
 - **Step 2**: Call OpenAI's API for advanced reasoning (cloud power)  
@@ -532,7 +532,7 @@ The revolution isn't just another framework — it's eliminating the template la
 
 **This is the Swiss Army knife approach:** Local by default, cloud by choice, with complete visibility into what's happening at each step. Whether you're processing confidential client data (local) or need cutting-edge AI capabilities (cloud), Pipulate gives you the framework to do both seamlessly.
 
-* **SQLite & Jupyter Notebooks:** Foundational tools for data persistence and the workflow development process (porting from notebooks to Pipulate workflows). SQLite is built into Python and really all things — the *get-out-of-tech-liability free card* you didn't know you had. And a full JupyterLab instance is installed side-by-side with Pipulate sharing the same Python `.venv` virtual environment, which is also shared with your preferred AI code editor (Cursor, Windsurf, VSCode, Zed) so... well... uhm, there are no words for when 3 different portals-to-Python share the same environment. You can do such stupid AI-tricks as letting your local LLM and a frontier cloud model *inhabit* the same body (Pipulate) — controlling web browsers together and stuff.
+* **SQLite & Jupyter Notebooks:** Foundational tools for data persistence and the workflow development process (porting from notebooks to Pipulate workflows). SQLite is built into Python and really all things -- the *get-out-of-tech-liability free card* you didn't know you had. And a full JupyterLab instance is installed side-by-side with Pipulate sharing the same Python `.venv` virtual environment, which is also shared with your preferred AI code editor (Cursor, Windsurf, VSCode, Zed) so... well... uhm, there are no words for when 3 different portals-to-Python share the same environment. You can do such stupid AI-tricks as letting your local LLM and a frontier cloud model *inhabit* the same body (Pipulate) -- controlling web browsers together and stuff.
 
 --------------------------------------------------------------------------------
 
@@ -574,7 +574,7 @@ We offer two installation paths that lead to the exact same robust, Nix-managed
                                       Result)
 ```
 
-### PATH 1: Quick Start — Universal Installation (Recommended)
+### PATH 1: Quick Start -- Universal Installation (Recommended)
 
 This is the fastest and most universal way to install Pipulate. It has the fewest dependencies and works on any modern Mac, Linux system, or Windows with WSL.
 
@@ -815,13 +815,13 @@ Pipulate is built on a radical philosophy that challenges programming orthodoxy:
 
 ### The Universal API Pattern: From Quarks to Code
 
-At every scale of reality, we see the same pattern: **"lumps of stuff" with APIs** that enable interaction. Quarks combine into atoms, atoms into molecules, cells into organisms, individuals into societies. Each level requires the right **granularity** of interface — not so abstract that you lose control, not so granular that you drown in complexity.
+At every scale of reality, we see the same pattern: **"lumps of stuff" with APIs** that enable interaction. Quarks combine into atoms, atoms into molecules, cells into organisms, individuals into societies. Each level requires the right **granularity** of interface -- not so abstract that you lose control, not so granular that you drown in complexity.
 
 **This is the 80/20 rule of existence:** Handle 80% of interactions gracefully with 20% of the API surface, then handle edge cases as needed. Pipulate applies this principle to code architecture.
 
 ### Durable vs. Ephemeral: Building on Bedrock
 
-The tech industry suffers from "hamster wheel syndrome" — constantly breaking APIs that force migration cycles. React (20+ versions), Node (frequent breaking changes), Angular (complete rewrites). This isn't progress; it's planned obsolescence.
+The tech industry suffers from "hamster wheel syndrome" -- constantly breaking APIs that force migration cycles. React (20+ versions), Node (frequent breaking changes), Angular (complete rewrites). This isn't progress; it's planned obsolescence.
 
 **Pipulate chooses durable foundations:**
 - **Linux Kernel**: Version 6 in 30 years
@@ -829,7 +829,7 @@ The tech industry suffers from "hamster wheel syndrome" — constantly breaking
 - **HTML**: Version 5 and stable
 - **HTTP**: Version 3 and backward compatible
 
-These are the "laws of physics" for software — stable APIs that enable compound growth rather than constant rebuilding.
+These are the "laws of physics" for software -- stable APIs that enable compound growth rather than constant rebuilding.
 
 ### Why WET Works Now
 
@@ -1023,7 +1023,7 @@ The UI is constructed primarily with server-rendered HTML fragments delivered vi
                              └─────────┴───────────┘  - No virtual DOM, JSX, Redux, etc.
 ```
 
-With such *minimal surface area* the AI code assistant *knows everything.* LLMs are either pre-trained on the stable, infrequently revved libraries used (Python 3.12, HTMX, or it's all small enough to fit in a 1-shot prompt — yes, the whole core code-base fits in one Gemini Web UI form submit.
+With such *minimal surface area* the AI code assistant *knows everything.* LLMs are either pre-trained on the stable, infrequently revved libraries used (Python 3.12, HTMX, or it's all small enough to fit in a 1-shot prompt -- yes, the whole core code-base fits in one Gemini Web UI form submit.
 
 --------------------------------------------------------------------------------
 
@@ -1048,7 +1048,7 @@ Designed for porting notebook-style processes, workflows are sequences of steps
 
 ### Run All Cells Pattern
 
-**The key insight**: Pipulate workflows use a `run_all_cells()` pattern that directly mirrors Jupyter's "Run All Cells" command. This creates an immediate mental model — each workflow step is like a notebook cell, and the system automatically progresses through them top-to-bottom, just like running all cells in a notebook.
+**The key insight**: Pipulate workflows use a `run_all_cells()` pattern that directly mirrors Jupyter's "Run All Cells" command. This creates an immediate mental model -- each workflow step is like a notebook cell, and the system automatically progresses through them top-to-bottom, just like running all cells in a notebook.
 
 ```text
     📓 JUPYTER NOTEBOOK               🌐 PIPULATE WORKFLOW
@@ -1263,7 +1263,7 @@ When a user hits Enter on an empty key field, this specific sequence occurs:
 Pipulate uses HTMX-driven step progression powered by the brilliantly named `run_all_cells()` method:
 
 1. **Initial Trigger**: After `init`, the `run_all_cells()` method initializes the workflow just like Jupyter's "Run All Cells"
-2. **Perfect Mental Model**: The method name creates immediate understanding — workflows execute top-to-bottom like notebook cells
+2. **Perfect Mental Model**: The method name creates immediate understanding -- workflows execute top-to-bottom like notebook cells
 3. **Step Handlers**: Each step has GET (display) and POST (submit) handlers
 4. **Automatic Progression**: Completed steps trigger next step with `hx_trigger="load"`
 5. **State Persistence**: Each step stores data in pipeline state
@@ -1279,7 +1279,7 @@ async def init(self, request):
 
 # ❌ ANTI-PATTERN: Manual placeholder creation
 async def init(self, request):
-    """Manual approach — harder to understand and maintain"""
+    """Manual approach -- harder to understand and maintain"""
     first_step_id = steps[0].id
     return Div(
         Div(id=first_step_id, hx_get=f'/{app_name}/{first_step_id}', hx_trigger='load'),
@@ -1592,11 +1592,11 @@ The system provides comprehensive debugging and state inspection capabilities th
 
 ## The Deeper Philosophy: Why This Matters
 
-Pipulate represents more than technology choices — it's a statement about **computing sovereignty** and the future of human-AI collaboration.
+Pipulate represents more than technology choices -- it's a statement about **computing sovereignty** and the future of human-AI collaboration.
 
 ### The Inevitable Retcon
 
-In a few years, the industry will pivot away from mutable containers and claim they invented "AI-Native Infrastructure"—declarative, reproducible environments that allow AI agents to write code without breaking dependencies. They will package it in slick UIs and hide the math.
+In a few years, the industry will pivot away from mutable containers and claim they invented "AI-Native Infrastructure"--declarative, reproducible environments that allow AI agents to write code without breaking dependencies. They will package it in slick UIs and hide the math.
 
 When that happens, remember that **Pipulate was here first.**
 
@@ -1608,11 +1608,11 @@ While others fight to keep their containers from drifting, you will be standing
 
 How do you "lift yourself up by your bootstraps"? The answer: **you're not a closed system**. Humans interact with reality through interfaces, just like software components. We are "human apps with reality APIs."
 
-This pattern repeats at every scale — from quantum fields to societies. The art lies in choosing the **right granularity** for these interfaces. Too abstract, and you lose control. Too granular, and you drown in complexity.
+This pattern repeats at every scale -- from quantum fields to societies. The art lies in choosing the **right granularity** for these interfaces. Too abstract, and you lose control. Too granular, and you drown in complexity.
 
 ### Every API is a Compromise
 
-The most successful APIs are **durable** — they become the "laws of physics" for their domain. In reality: the laws of physics, chemistry, biology. In tech: logic gates, operating systems, protocols like HTTP and HTML.
+The most successful APIs are **durable** -- they become the "laws of physics" for their domain. In reality: the laws of physics, chemistry, biology. In tech: logic gates, operating systems, protocols like HTTP and HTML.
 
 Pipulate chooses these durable APIs deliberately, creating a **future-proof foundation** for AI-assisted development that will outlast the current framework churn.
 
@@ -1630,9 +1630,9 @@ Remember the guiding principles:
 2.  **Support local-first with cloud integration options.**
 3.  **Embrace the unconventional while remaining practical.**
 4.  **Choose durable foundations that work with any approach.**
-5.  **Build for both human creativity and AI collaboration—local or cloud.**
+5.  **Build for both human creativity and AI collaboration--local or cloud.**
 
-**The Bottom Line:** Pipulate doesn't reject the modern AI ecosystem—it provides a structured foundation that works with any AI service. Whether you're using Claude via API, ChatGPT for reasoning, or local models for privacy, Pipulate gives you the workflow framework to orchestrate them all effectively. It's not about choosing sides in the AI wars—it's about having the right tool for any job.
+**The Bottom Line:** Pipulate doesn't reject the modern AI ecosystem--it provides a structured foundation that works with any AI service. Whether you're using Claude via API, ChatGPT for reasoning, or local models for privacy, Pipulate gives you the workflow framework to orchestrate them all effectively. It's not about choosing sides in the AI wars--it's about having the right tool for any job.
 
 -----