The Prompt Router Has Two Words: Simplifying Replayable AI Workflows
Setting the Stage: Context for the Curious Book Reader
Important to know in the Age of AI, building maintainable local-first pipelines often requires reducing command surfaces until anyone can execute them reliably. This session explores how Pipulate streamlines iterative prompt engineering down to two core commands, making local toolchains as checkable and inspectable as a standard text document.
TL;DR: This entry records one development session on Pipulate, a locally run toolkit that captures web pages from a real browser into a private archive and compiles selected files and command outputs into one text payload for a large language model. The session first tested the newcomer’s path on a fresh macOS install (one curl command, a three-page browser walk, a saved preview), then added two shell commands: epr opens the file the walk writes, a list of what the model should see, and cpr compiles that list into the clipboard and a hash-named zip. The walk’s list now names a size-capped, checked preview instead of the raw multi-megabyte archive, and the writer refuses to overwrite a list a human has edited. A change that made epr open a second editor window was tried and reverted within the hour. The remaining work is itemised at the end: an end-to-end run of the new list-writing path, a home for the newcomer’s question, and turning connector shell aliases into commands that scripts can call.
Technical Journal Entry Begins
🔗 Verified Pipulate Commits:
MikeLev.in: Alright now this is a case of testing the system under stress. Stress testing a system is a good thing. We’re reducing number of things to type and understand before a good positive payoff. Now asides from the fact that this process assumes you can edit in vim / NeoVim, the introductory process now to the point where you can plan and run your whole own DevTools Network-tab capturing walk (including the source HTML, hydrated DOM, the diffs and so much more) is just:
- From a terminal:
curl -fsSL https://npvg.org | bash - Type “2” to exit to terminal.
- A menu appears. Enter “2” to start a real walk (and capture).
And I just tested this on the Mac:
A Cold Start on the Mac
(nix:nix-shell-env) (nix) npvg $ exit
exit
Saving session...
...saving history...truncating history files...
...completed.
Deleting expired sessions...none found.
michaellevin@MichaelMacBook-Pro ~ % rm -rf npvg
michaellevin@MichaelMacBook-Pro ~ % curl -fsSL https://npvg.org | bash
Npvg -> ~/npvg (to remove it later: rm -rf ~/npvg)
Deploy key saved to .ssh/rot (public, pull-only: it lets this folder fetch updates without a GitHub account).
To come back later: cd ~/npvg && nix develop
Hydrating the Nix environment (the first time can take a few minutes)...
Restored session: Wed Sep 16 06:09:37 EDT 2026
✅ Transformed into a git repository (pre-transform files backed up to /tmp/nix-shell.JXVycJ/tmp.F91Sq7sPdB).
Already up to date.
Found ~/.ssh/id_rsa -- switching the git remote to SSH so auto-updates use it.
(Determinate Nix 3.19.1) 2.34.6 · Python 3.12.13 · v2.57 · ~/npvg
🔧 Fresh install detected — packages downloading...
✅ 291 packages ready.
📓 12 starter file(s) copied into Notebooks/ -- yours to edit.
╭────────────────────────────── nix develop -- a reproducible *nix shell :: pick a door ──────────────────────────────╮
│ │
│ [1] JupyterLab tab both servers start; JupyterLab opens in the browser │
│ [2] Text Commands nothing starts -- five words wait at the prompt │
│ [3] Pipulate tab both servers start; the app opens in the browser │
│ │
╰───────────────────────────── waiting for your choice -- Ctrl+C also drops to the shell ─────────────────────────────╯
[2] Text Commands. Nothing started -- no JupyterLab, no server.
Five words to start from:
walk take the guided tour -- public pages, nothing to log into
sources see what this shell can reach outside this machine
brief compile this workshop into your clipboard for an AI -- the context compiler's first job
pu change your mind and start the app server after all
menu print this list again once it scrolls away
(nix:nix-shell-env) (nix) npvg $ walk
Trail resolved: assets/trails/public_walk.json
This walk opens three public pages. Nothing to sign in to.
Return here and type CAPTURE when prompted at each page.
After all three captures and successful checks, it tries to save a private summary
and tries to replace your clipboard. Over SSH it uses a bridge file.
Nothing is sent to a chatbot. Review the summary before sharing it.
Choose a walk:
1 Practice - hear the steps; no pages open.
2 Start the walk - open the pages.
q Exit (Enter also exits).
Choice: 2
Riding trail 'public_walk' -- 3 stop(s).
/Users/michaellevin/npvg/.venv/lib/python3.12/site-packages/huggingface_hub/utils/_validators.py:205: UserWarning: The `local_dir_use_symlinks` argument is deprecated and ignored in `hf_hub_download`. Downloading to a local directory does not use symlinks anymore.
warnings.warn(
en/en_US/amy/low/en_US-amy-low.onnx: downloading bytes: ██████████████████████████████████████████| 59.5MB, 5.33MB/s
en/en_US/amy/low/en_US-amy-low.onnx: reconstructing file: 100%|██████████████████████████| 63.1MB / 63.1MB, 5.90MB/s
Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.
en_US-amy-low.onnx.json: 100%|███████████████████████████████████████████████████| 4.16k/4.16k [00:00<00:00, 5.93MB/s]
This walk opens three pages. You do not need to click anything. At each page, return here and wait for the CAPTURE prompt. Type CAPTURE and press Enter.
Missing phoneme from id map: ̩
This walk opens three public pages. Nothing to sign in to.
Return here and type CAPTURE when prompted at each page.
After all three captures and successful checks, it tries to save a private summary
and tries to replace your clipboard. Over SSH it uses a bridge file.
Nothing is sent to a chatbot. Review the summary before sharing it.
Summary file: data/decant-preview.md (private; replaced on save).
Checks can miss private details. A blocked check leaves the older file alone.
--- Stop 1/3: the_word ---
I'll open page one. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.
Opening the browser; waiting for the page...
2026-09-16 06:11:14.245 | WARNING | tools.scraper_tools:_selenium_capture:571 - ⚠️ Chrome version mismatch detected. Auto-healing with version_main=152
When the page you want is ready, type CAPTURE and press Enter.
Any other response aborts without capturing artifacts.
CAPTURE> CAPTURE
LOCAL ARCHIVE /Users/michaellevin/npvg/data/captures/walk-s1cltzx1/captures.md (directory 0700, file 0600)
Captured. final_url=https://npvg.org/walk/1/ artifacts=12
ADVANCE -> next stop.
--- Stop 2/3: the_receipt ---
I'll open page two. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter.
Opening the browser; waiting for the page...
2026-09-16 06:11:53.149 | WARNING | tools.scraper_tools:_selenium_capture:571 - ⚠️ Chrome version mismatch detected. Auto-healing with version_main=152
When the page you want is ready, type CAPTURE and press Enter.
Any other response aborts without capturing artifacts.
CAPTURE> CAPTURE
Captured. final_url=https://npvg.org/walk/2/ artifacts=12
ADVANCE -> next stop.
--- Stop 3/3: the_two_pages ---
I'll open the last page. When it is ready, return here. At the CAPTURE prompt, type CAPTURE and press Enter. Then read the result here.
Opening the browser; waiting for the page...
2026-09-16 06:12:48.208 | WARNING | tools.scraper_tools:_selenium_capture:571 - ⚠️ Chrome version mismatch detected. Auto-healing with version_main=152
When the page you want is ready, type CAPTURE and press Enter.
Any other response aborts without capturing artifacts.
CAPTURE> CAPTURE
Captured. final_url=https://npvg.org/walk/3/ artifacts=12
ARCHIVE STATUS complete
Local archive file line for context.md or adhoc.txt:
/Users/michaellevin/npvg/data/captures/walk-s1cltzx1/captures.md
Review locally before compiling; raw bytes are not a safe disclosure.
WALK ROUTER /Users/michaellevin/npvg/adhocwalk.txt (0600; UNSANITIZED; not compiled)
Ride complete. Every stop produced a capture receipt.
Checking the summary before saving it and trying the clipboard.
Preview checks: substitutions=0 denylist=0 secrets=0
LOCAL PREVIEW /Users/michaellevin/npvg/data/decant-preview.md (0600; sha256=444dace1b252a9122a84e86c5c11a63bbbfcb299f3a45fc3d5255008b75b25ed)
Markdown output copied to clipboard
Read the save and copy messages above; either step can fail.
Review the summary before sharing it. You choose what to send.
The three-page walk is finished. Read the save and copy results in your terminal. Review any summary before sharing it. Goodbye.
--------------------------------------------------------------
CAPTURE RUN FINISHED
--------------------------------------------------------------
Read the save and copy messages above. Either step can fail.
Review the summary before sharing it.
Nothing was sent to a chatbot.
--------------------------------------------------------------
(nix:nix-shell-env) (nix) npvg $ vim /Users/michaellevin/npvg/data/decant-preview.md
(nix:nix-shell-env) (nix) npvg $
This is good! This is the basis starting point now that almost anyone can go through. Okay I’ve only got about an hour window now to hit this all home. It’s okay to have to hand-cobble a bit here and there together for the big picture but the big picture now is:
- Here is a Jira ticket. We’re going to address, solve and close it with that archive that this system produces to go along with it. Any questions about how the ticket resolved is answered by “Drop the archive into Claude” and it will not only be able to explain that to you, but it will be able to reproduce it on its own, show you how to reproduce it and that all can be done with any decent frontier model other than Claude as well.
- First you need to see how anything you do in the browser, even a series of things with very complex moves of click this, do that, do this other thing and whatever can all be reproduced in a walk so long as URLs using the GET method is how you do this or that. Actual automation that mutates target machines is a different thing and we can talk about that later. This is web-based “report capture” with everything called to build pages captured too.
- That produces a filename on your system which goes into a router file so that
Claude can start helping you with subsequent drill-down knowing what’s
sitting just captured on your machine and where. You can’t include everything
captured because that would explode the context-window so you include in this
case
/Users/michaellevin/npvg/data/decant-preview.mdinto some other “router” file such asadhoc.txt(the one I always edit) or some new one that was automatically created at/Users/michaellevin/npvg/adhocwalk.txtwhose content reads:
Oh, well that’s not as easy as a 1, 2, 3 set of instructions as I would have
liked. The contents of that adhocwalk.txt file by the way is:
# Generated: last completed nonempty capture run.
# Replaced on completion; partial or empty runs leave this selection unchanged.
# UNSANITIZED local evidence; review before disclosure or compilation.
/Users/michaellevin/npvg/data/captures/walk-s1cltzx1/captures.md
…which is the absolute perfect starting point for this next step. I can probably knit this together now even in this shrinking window of time that I have because that’s simply where you layer in commands like:
# Generated: last completed nonempty capture run.
# Replaced on completion; partial or empty runs leave this selection unchanged.
# UNSANITIZED local evidence; review before disclosure or compilation.
/Users/michaellevin/npvg/data/captures/walk-s1cltzx1/captures.md
jira https://botify.atlassian.net/browse/SWCX-1234
gmail "Exact subject"
Usually then I type ahc for “Ad Hoc Chop” that goes along with ahe for “Ad
Hoc Edit” which has this beautiful symmetry:
prompt
ahe
ahc
…which is:
- Paste the prompt you just copied into your operating system copy-buffer as
prompt.mdusually in whatever folder is your main Pipulate repo. - Edit the temporary out-of-bounds OOB (git will never see it) router file. We do it OOB so you can feel free to put customer info in there.
- Compile the “big” prompt using the smaller
prompt.mdyou just created at the bottom and all the other stuff in the order they appear in the router above with all kinds of “Table of Contents for AI” (ToC4AI?) layered in so the LLM can deal with the “lost in the middle” problem just as a human would with good book navigation devices.
Right, right. So we’ve just about closed the loop here. I need something
different from ahe and ahc for when people are on this other path staring
with a cold intro to the system. It goes something like:
The Prompt Router Gets Two Names
- Install
- Take a walk for initial captures and creating router file
- Edit router file for fuller, better context
- Compile and send to LLM
- Ride the 5-Car Train until problem, puzzle or riddle is reproducibly solvable by any decent frontier AI model you give the resulting archive to.
Do a big abstract Tortoise-turn pass on this. I know I’m time-constrained right
now but we do need to paint the 40K-foot picture here for the New-B just joining
in on this article as if cold start, then we’ll pivot this article to the ahe
and ahc alternatives this suggests we need.
Fable 5.1 Extra: Context verified. The roster carries what both halves of this turn need. The one file the pivot itself will need and this compile lacks is scripts/boot_menu.py, which owns the door-2 word list; it rides next turn.
Two live readings set the frame. The source probe reads canonical=public_walk.json default=public_walk.json stops=3 compiler_json=True, so the rename is complete in the mechanism. The integrity checker in this same compile reports 1 broken of 44 candidates: assets/trails/public_walk.yaml: the rename landed in the code and the router’s chapter VIII-b roster never followed it, which is also why the Paintbox now lists public_walk.json as unclaimed. That is Car 1. And your Mac transcript witnesses the cold path on macOS end to end, from rm -rf npvg to a saved preview and a filled clipboard, closing sentence printed. You did not say you heard it, so the audio stays unreported on that machine. Two more facts from that transcript matter below: the walk router landed at ~/npvg/adhocwalk.txt there and at ~/.local/state/pipulate/adhocwalk.txt here, which is the writer’s derivation doing its job, and the file it names is captures.md, not the preview.
The picture, for someone who walked in just now
You ask an AI about a web page, a ticket, a report. It answers fluently. You now have a second job, checking the answer, and you cannot do it, because you cannot see what the model saw. It saw a summary of a summary, or nothing, and filled the gap with the most probable sentence. Every complaint about “QA-ing the LLM” is this one complaint.
The fix is not a smarter model. It is a better package, with three parts.
The recorder. A walk opens pages in a real browser on your own logged-in session and stops at each one until you type CAPTURE. What lands on disk at that word is the page as the server sent it, the page as the browser built it, the difference between those two, every request the page made while loading (the DevTools Network tab, as a file), the response headers, and the page’s outline. It lands twice. The archive is everything, unsanitized, megabytes, and stays on your machine. The preview is the readable lenses, capped, passed through the same identity and secret checks the compiler runs, and copied to your clipboard. The first payoff needs no editing at all: paste the preview into any chatbot and ask what page three changed. A walk is a list of addresses, so anything you can reach by typing an address into a logged-in browser can be walked; a click that changes something on the server cannot, on purpose. The recorder records and does not touch.
The list. One text file, one line per thing: a file path, or a command with ! in front. That is the entire grammar. The compiler stacks each line’s text into one document with a table of contents on top and your question at the bottom. The table of contents is not decoration. It says where the question is and which command outputs are fresh from this compile, so the model cannot cite a stale reading from earlier in the conversation. The walk writes a first version of this list for you: one line, the archive’s path, plus three comment lines saying it is unreviewed evidence.
The seal. Every compile writes a zip whose name carries the hash of its own bytes. Same inputs, same bytes, forever, and a ten-line standard-library script verifies it. That zip is what you attach to the ticket. “Drop the archive into Claude” works because the payload inside it ends with the question and begins with the map.
The loop, in the words that exist and the two that do not yet:
curl -fsSL https://npvg.org | bash, then2. Nothing starts; five words wait.walk, then2, then CAPTURE three times. Preview in the clipboard, archive on disk, list written.planedits your own list of pages;walk planrides it.pickopens the list the walk wrote. Add lines. Today a connector line is spelled! python scripts/connectors/jira.py SWCX-1234; swap the archive line for the preview’s path.pack "What does this ticket need?"compiles the list and the question into your clipboard and a sealed zip. Paste it.- The reply ends in a train: probes to run, the next list, patches to apply with
patchthenapp, the next question. Run, apply,packagain, until any capable model handed the zip reaches the same place. deed <zip>keeps that zip out of rotation. Attach it to the ticket.
Three words carry it: walk, pick, pack. The editor is the one soft spot you named, and it is softer than you said: neovim is not in the flake’s package list, so plan and pick run on whatever the host machine has.
Three strikes, in order of cost
“It will not even have the opportunity to confidently hallucinate, and the LLM knows it would be documented and therefore won’t.” No. A model does not know it is being recorded and does not behave better for it; the transcript replays and nobody is in there to be deterred. What the archive changes is not the model’s conduct but yours: every claim in the reply is checkable against bytes sealed before the claim was made, so a wrong claim costs one read instead of one afternoon. The team-facing promise is “you can inspect what the answer was based on,” and that promise survives a model that lies, which is why it is the one to sell. THE FLIGHT-RECORDER POSITIONING already refuses the other sentence.
“It will be able to reproduce it on its own.” Two reproductions, and conflating them is the overclaim. Any model handed the zip can re-derive the analysis: verify the seal, read the evidence, reach your conclusion or a different one, and either is information. Only a machine with the trail and a logged-in profile can re-run the capture. The archive replays the reasoning; the walk replays the recording. foo_replay.py says as much in its own roster line.
jira https://botify.atlassian.net/browse/SWCX-1234 as a bare line in the list. Two things are wrong with it today, and they are the pivot’s third decision. A bare line is parsed as a path, and one with a space trips the de-prefixed-command warning. With the ! added, jira is a shell alias, and THE THREE-TIER AMENDMENT is exact about this: an alias is reachable only by a human typing it as the first word, a function only by code in the same shell, and a word a child process must resolve needs a package on PATH. The ! executor is a child process. posts, rgx, rgxc, ai-commit and deed are packages for that reason; the seven connectors are aliases. Until they are packages, the honest spelling is the long one, and the New-B pays for it on the first line they ever add.
The pivot: two words and three decisions
Names first, under your veto. pick opens the walk router: you pick what rides to the AI. pack "question" compiles it, question and all: the compiler packs a payload. Both pass the ATTRIBUTED-VOICE mechanical test, which ask and ship fail (nothing asks, nothing ships, a human pastes) and which send fails the same way. list was refused as a verb too generic to be found again by two rare words. ahe and ahc stay the expert spellings of the same two moves against adhoc.txt.
Under the names, one bug that bites you before it bites any stranger. mother_cat._write_walk_router derives its target beside the human router: it reads PIPULATE_ADHOC_FILE, defaulting to $PIPULATE_ROOT/adhoc.txt, and swaps the filename. ahcw names $PIPULATE_ROOT/adhocwalk.txt outright, which is where the file lands only while the variable is unset. Right on the Mac, ROUTER REFUSED on the machine that set the variable, and the two transcripts in this payload show both landings. Car 2 spells the writer’s derivation once and reads it from ahcw, pick and pack.
Then the three decisions the next turn owns, each its own car:
Keeping the Preview in the Loop
First, the list the walk writes names captures.md, the whole archive, and compiling that line is the context explosion the New-B is being spared. You said it yourself in the prompt: the preview is what rides. The candidate is for the router to name data/decant-preview.md as its active line when DECANT was authorized and keep the archive path as a commented drill-down line, and it is not a one-liner, because the router is written before the preview exists, on purpose, so a router failure cannot block DECANT. Whether the write moves or a second write follows is the decision; mother_cat.py rides next turn for it.
Second, the door-2 list in boot_menu.py does not know the new words. A menu that omits a word is not lying, but THE SAME-CAR LABEL RULE says the label moves with the gate; it needs the file in context.
Third, the connectors as packages, so ! jira SWCX-1234 is a legal line. Seven writeShellScriptBin entries in the shape aiCommitCommand already uses, the aliases deleted so there is one spelling, and the sources roster reading the same words. One flake car, and a big enough one that it should not ride in the hour you have.
Small noise from the Mac transcript, named and not fixed: a Chrome version mismatch detected. Auto-healing warning printed at every stop, three times, at the moment a stranger is reading; and six lines of Hugging Face chatter around the sixty-megabyte voice download on a first walk. Both are warnings firing on the ordinary case.
1. PROBES
The rg line prints the roster line, not a count, so the reading is the line itself moving from .yaml to .json; by hand it prints three lines before and after (the 2026-08-01 prose line, the roster, the Paintbox row), and in the compile it prints two, because the Paintbox regenerates at step 2 before the executor runs. The ls line is a CENSUS: it names which of the two candidate walk-router paths exists on this machine and reads the same before and after by design; it proves Car 2’s premise, not its landing. The hook probe is the compile-lane witness for the flake cars, since shell functions are invisible to the ! executor: quiet_hook_syntax=ok is a gate, and walkrouter_lines is the reading, 0 before, 2 after Car 2, 4 after Cars 2 and 3.
rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
ls -l "$PIPULATE_ROOT/adhocwalk.txt" "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok walkrouter_lines=%s\n" "$(printf "%s\n" "$hook" | grep -c "_walkrouter" || true)"'
2. NEXT CONTEXT
A lean compile: the pivot needs the router, the flake, the menu, the rider and the launcher, not the forty-thousand-foot roster. Prune the old commented Context blocks while you are in there; the checker reads a bare path on a commented line as a toggled-off pin, so they are the second source of the public_walk.yaml alert and Car 1 clears only the first.
# Context 7 (the pivot: two words after the walk)
foo_files.py
flake.nix
scripts/boot_menu.py
scripts/mother_cat.py
assets/installer/mck.sh
! rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
! ls -l "$PIPULATE_ROOT/adhocwalk.txt" "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok walkrouter_lines=%s\n" "$(printf "%s\n" "$hook" | grep -c "_walkrouter" || true)"'
3. PATCHES
Car 1: the router’s roster follows the rename. A mid-line anchor, because the roster’s alignment padding cannot be counted through transport and the suffix swap keeps the column.
Target: foo_files.py
[[[SEARCH]]]
# assets/trails/public_walk.yaml
[[[DIVIDER]]]
# assets/trails/public_walk.json
[[[REPLACE]]]
Car 2: the walk router’s path is derived, never named, and ahcw reads the derivation.
Target: flake.nix
[[[SEARCH]]]
ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$PIPULATE_ROOT/adhocwalk.txt" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
[[[DIVIDER]]]
# THE WALK ROUTER LIVES BESIDE THE HUMAN ROUTER (convicted 2026-09-16,
# two transcripts): mother_cat._write_walk_router derives its target
# from PIPULATE_ADHOC_FILE -- default $PIPULATE_ROOT/adhoc.txt -- and
# swaps the filename, so a shell that points the variable outside
# the worktree gets adhocwalk.txt outside the worktree too. The old
# spelling here named $PIPULATE_ROOT/adhocwalk.txt outright, which is
# where the file lands only while the variable is UNSET: right on a
# fresh Mac install, ROUTER REFUSED on the machine that set it. One
# derivation, the writer's, spelled once and read by every word below.
_walkrouter() { printf '%s/adhocwalk.txt\n' "$(dirname "''${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")"; }
ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
[[[REPLACE]]]
Car 3: the two words. Depends on Car 2; veto it alone if the names are wrong and the mechanism stays.
Target: flake.nix
[[[SEARCH]]]
ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
[[[DIVIDER]]]
ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
# THE TWO WORDS AFTER THE WALK (proposed 2026-09-16; the names sit
# under the coachman's veto, the mechanism does not). walk teaches,
# plan edits your itinerary, walk plan rides it -- and then the rider
# has written the walk router and the newcomer has no plain word for
# what comes next. pick opens that router: pick what rides to the AI,
# one path or one `! command` per line. pack "your question" compiles
# it, question and all, into the clipboard and a sealed cartridge;
# bare pack reads prompt.md if one exists. ahe and ahc are the expert
# spellings of the same two moves against adhoc.txt. Both words pass
# the ATTRIBUTED-VOICE mechanical test -- a human picks lines and the
# compiler packs a payload -- where ask and ship do not: nothing here
# asks or ships, a human pastes. FUNCTIONS, per THE THREE-TIER
# AMENDMENT: typed by a human, never echoed as a probe; the compile
# lane witnesses them in the generated hook text.
pick() { (cd "$PIPULATE_ROOT" && nvim "$(_walkrouter)"); }
pack() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py "$@" --chop ADHOC_CHOP --no-tree); }
[[[REPLACE]]]
Ignition for Cars 2 and 3: exit then ndq. The hook is read once at entry, so the hook-text probe witnesses the text and only a human at the new prompt witnesses the words. After re-entry, type _walkrouter and read the path, then ls -l it; pick should open the file the walk wrote here, and pack "smoke" should print ROUTER LOADED for that same path. Car 1 needs no ignition; the rg line reads the file at call time.
4. PROMPT
Continue THE TWO WORDS AFTER THE WALK. Read this compile's Manifest-listed live receipts first.
Last turn proposed three cars: (1) foo_files.py chapter VIII-b roster line public_walk.yaml -> public_walk.json; (2) flake.nix: a helper deriving the walk router's path beside the human router, the same derivation mother_cat._write_walk_router uses, with ahcw reading it; (3) flake.nix: pick (open the walk router in nvim) and pack "question" (compile it through ADHOC_CHOP with the question as the prompt). Expected: the rg census on foo_files.py shows the roster line reading .json and, in the compile lane, the Paintbox row gone (3 lines by hand, 2 in the compile); the quiet hook parses with walkrouter_lines 0 -> 4 (0 -> 2 if car 3 was vetoed); the ls census names which of the two candidate walk-router paths exists on this machine and reads the same before and after by design. Ignition for cars 2-3 was exit then ndq. Treat pick and pack as witnessed only from my operator report below, never from the hook count.
Then the pivot proper, three decisions, each its own car with its own probe, in this order. (a) The router the walk writes names captures.md, the whole unsanitized archive, and compiling that line is the context explosion the newcomer is being spared; decide whether _write_walk_router names data/decant-preview.md as the active line when DECANT was authorized and keeps the archive path as a commented drill-down line, and whether that write moves after _complete_preview or a second write follows it, given that the current order exists so a router failure cannot block DECANT. (b) scripts/boot_menu.py DOOR_TWO_WORDS gains pick and pack so the door-2 list does not omit them. (c) Whether the connector aliases (jira, email/gmail, botify, confluence, slack, sheets, gsc) become writeShellScriptBin packages in the shape aiCommitCommand already uses, aliases deleted so there is one spelling, so that `! jira SWCX-1234` is a legal router line under the ! executor per THE THREE-TIER AMENDMENT; if that car is too wide for the window, say so and name the long spelling the newcomer types instead.
Keep the promise language: inspectable, never hallucination-free; re-derive the analysis from the archive, re-run the capture from the trail. Do not start the Botify SpeedWorkers work.
Operator report:
Terminal transcript:
5. EXTERNAL DELIVERABLES
No external deliverables this turn.
MikeLev.in: We’re back to Fable 5.1 which will be interesting after a round of work from Opus 5 and a couple more from ChatGPT 6.
Same commands, run twice, one change between them. Where the readings differ is what the change did; the diff in the middle is the receipt.
1: Probe: (BEFORE: hand-run, nothing changed yet)
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
ls -l "$PIPULATE_ROOT/adhocwalk.txt" "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok walkrouter_lines=%s\n" "$(printf "%s\n" "$hook" | grep -c "_walkrouter" || true)"'
744:# FIRST WALKTHROUGH SHIPPED 2026-08-01: assets/trails/public_walk.yaml rode
1671:# assets/trails/public_walk.yaml # profile default; SETTLE trivial; three unlinked npvg.org pages (the_word, the_receipt, the_two_pages), inline script on stop three only, connector noop.py; RIDDEN 2026-09-15 on these stops, 3 of 3 at artifacts=11 each, archive complete, DECANT AUTHORIZED at 20,992 B with checks 0/0/0, and the chatbot given stop three's question said the preview does not carry the server's sentence, which is true (the diff-lens TODO); the 2026-08-01 ride walked the OLD stop set (example.com, mikelev.in, pipulate.com); what bare `walk` rides
3054:# assets/trails/public_walk.json # [510 tokens | 1,833 bytes]
ls: cannot access '/home/mike/repos/pipulate/adhocwalk.txt': No such file or directory
-rw------- 1 mike users 267 Sep 16 04:35 /home/mike/.local/state/pipulate/adhocwalk.txt
quiet_hook_syntax=ok walkrouter_lines=0
(nix) pipulate $
2: Context: (AFTER: the same probes re-run by the compiler as ! lines)
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | Chasing big payoffs by lightweight dot-connecting!
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | |
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# To Human: WELCOME TO VIM! It's really NeoVim but I say vim anyway.
# To AI: This is an alternate 40K view to the big book-ore rolling pin spine.
# 1. **Probe**: Baseline Reading
# 2. **Context**: Post-experiment *planned* reading instructions
# 3. **Patch**: The experiment and how to make it happen
# 4. **Prompt**: Post-experiment instructions and how to read results
# 5. **Deliverable**: How the world is forever different moving forward
# The first thing you need to know here is that everything that comes after the
# hash symbol (#) is commented out — and that's EVERYTHING in this file's default
# state. Begin editing-in lines for inclusion as part of the context or adding
# chunks of new context at the bottom. `Ctrl`+`v`, `j` (repeatedly), `l` (to move
# right), `d` (to delete). Reverse that with `Ctrl`+`v`, `j` (repeatedly),
# `Shift`+`i`, `# `, `Esc` to put the hashes back. You can just arrow-key around
# here with `h`, `j`, `k`, `l`. Save-and-quit is a bit tricky because another
# file is also loaded: `Esc`, `:`, `q`, `w`, `!`
# If this is stressing you out and you're a quitter and want to quit, just type:
# `Esc`, `:`, `q`, `!`, `Enter`. That will exit without saving any changes. If
# you want to get over this hump, type: `Esc`, `:`, `T`, `u`, `t`, `o`, `r`, `Enter`.
# This file is just to make it easy having options of what to edit into context.
# You can use whatever text-file you want to stack file-names and commands to
# build an output text-file with the identically stacked output of each file or
# command. In this way we vertically append or "stack" a bunch of text; simple as
# that. If you understand this concept, you're on your way to future-proofing
# yourself in the Age of AI. Congratulations! Here is how to include web pages:
# !URL --------------------------------------------------------------------
# when Public page; what a stranger or crawler sees; the BEFORE of a
# login-wall diagnosis
# switch It shows a login page -> `warm URL` once, then `?URL`
#
# ?URL --------------------------------------------------------------------
# when Anything behind a login, on the site's persistent profile;
# `check URL` first
# switch The lenses show a shell (nav, an `[Iframe]` leaf, no content) ->
# read the wire truth for the XHR the frame makes, then call that
# API with a connector
#
# @URL --------------------------------------------------------------------
# when Every re-read of a page already scraped; no browser, no network
# switch The cached page is stale or was a login wall -> fresh `!` or `?`
#
# $URL --------------------------------------------------------------------
# when Exact markup: meta tags, a JSON blob in a `<script>`
# note Token-heavy; needs a prior scrape
#
# %URL --------------------------------------------------------------------
# when The network log distilled; SPA endpoint discovery
# switch It re-serves the wire truth you already have -> the API
#
# ! cmd -------------------------------------------------------------------
# when Any bounded, non-interactive command as a live receipt
# note Cap it with `-n`; no aliases, no prompts
#
# Connector ---------------------------------------------------------------
# when The number you want is one GET away
# switch LIST until the thing isn't in the list -> FETCH by id -> DRILL
# the path the app's own frame called -> `--grep` to narrow a list
# or find a leaf
# Every step is one argument longer than the last; the moment a lens shows less than the wire does is the moment to stop scraping.
# FOR 40K-FT VIEW (STORY & INFRASTRUCTURE)
# --- START EDITING-IN ON 1ST TURN ---
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- ROLLING PIN that gives the 40K foot book-spine view of book-ore (only works for me because of local-only git repo)
# ~/repos/nixos/autognome.py # <-- You wake up in the morning and your Tooling & Instrumentation folds out of you like Inspector Gadget.
# init.lua # <-- Those gadgets are made easy-to-use through nifty keyboard shortcuts (but ya gotta learn vim).
# GLOSSARY.md # <-- Like the back of a J.R.R. Tolkien book, there's kooky new terms to know.
# flake.nix # <-- Here is my hardware. Here is my state. Put on your sandbox. And please recreate. (Infrastructure as Code / IaC)
# prompt_foo.py # <-- THIS system
# foo_files.py # <-- main ROUTER
# requirements.in # <-- We've "pinned" everything but still want a flexible Python Data Science virtualenv.
# pyproject.toml # <-- How this is a citizen of the Python "pip install" ecosystem
# __init__.py # <-- Version info
# --- END EDITING-IN ON 1ST TURN ---
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# OPTIONAL ACTUATORS (cheap and good to include to expand the AI's capabilities)
# cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
# scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
# scripts/crawl.py # <-- Feel free to ask for something to be crawled and included in the next turn.
# scripts/weblogin.py # <-- Lets the user "warm up" the cache for their web logins at their leisure on a profile that persists.
# scripts/webclip_2_markdown.py # <-- Surprisingly important program.
# MISCELLANEOUS (rare to include but sometimes critical)
# scripts/foo_cartridge.py # Needs description
# scripts/foo_replay.py # Needs description
# release.py # <-- How everything ends up where it does (GitHub, PyPI, etc.)
# imports/voice_synthesis.py # <-- The wand can talk to you
# imports/ascii_displays.py # <-- Where all the ASCII Art lives
# scripts/release/version_sync.py # <-- Needs to be wrapped into release.py and eliminated, I think.
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
# Carry-over as the important work-in-progress parts of the project here just
# like above but not as long-standing overarching to the framework but rather
# for the current hot spots actively being worked on.
# STICKBUG & MOTHER CAT KATA (WORKING ON THE CHAPTER)
# Always include these with whatever connector
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# scripts/connectors/confluence.py
# scripts/connectors/gmail.py
# scripts/connectors/gsc.py
# scripts/connectors/jira.py
# scripts/connectors/mcp.py
# scripts/connectors/mcp_warm.py
# scripts/connectors/sheets.py
# scripts/connectors/slack.py
# --- START THIS DISCUSSION ---
# Get things started here! Guess at what context should be included.
# If you get it wrong, you're just wasting 1-turn because the AI will help.
# Un-comment lines, add lines with absolute-path filenames or `! ` commands.
# Content 1
# /home/mike/repos/trimnoir/_posts/2026-09-16-walk-plan-run-replayable-workflows.md # [Idx: 1475 | Order: 1 | Tokens: 41,920 | Bytes: 166,717]
# foo_files.py
# cli.py
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# ! .venv/bin/python cli.py mcp-discover
# ! .venv/bin/python scripts/connectors/botify.py --help | head -80
# Context 2
# Context 7 (the pivot: two words after the walk)
foo_files.py
flake.nix
scripts/boot_menu.py
scripts/mother_cat.py
assets/installer/mck.sh
! rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
! ls -l "$PIPULATE_ROOT/adhocwalk.txt" "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok walkrouter_lines=%s\n" "$(printf "%s\n" "$hook" | grep -c "_walkrouter" || true)"'
# --- END `adhoc.txt` TEMPLATE ---
3: Patches: (the one change between the readings)
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'foo_files.py'.
(nix) pipulate $ d
diff --git a/foo_files.py b/foo_files.py
index e7bb5743..aaaaf8fc 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -1668,7 +1668,7 @@ __init__.py # <-- Version info
# tests/test_mck_rep2.py # <-- Rep 2: the earmark's owed side-by-side witness
#
# THE TRAILS (bundled; each status is the newest receipt, never a promise)
-# assets/trails/public_walk.yaml # profile default; SETTLE trivial; three unlinked npvg.org pages (the_word, the_receipt, the_two_pages), inline script on stop three only, connector noop.py; RIDDEN 2026-09-15 on these stops, 3 of 3 at artifacts=11 each, archive complete, DECANT AUTHORIZED at 20,992 B with checks 0/0/0, and the chatbot given stop three's question said the preview does not carry the server's sentence, which is true (the diff-lens TODO); the 2026-08-01 ride walked the OLD stop set (example.com, mikelev.in, pipulate.com); what bare `walk` rides
+# assets/trails/public_walk.json # profile default; SETTLE trivial; three unlinked npvg.org pages (the_word, the_receipt, the_two_pages), inline script on stop three only, connector noop.py; RIDDEN 2026-09-15 on these stops, 3 of 3 at artifacts=11 each, archive complete, DECANT AUTHORIZED at 20,992 B with checks 0/0/0, and the chatbot given stop three's question said the preview does not carry the server's sentence, which is true (the diff-lens TODO); the 2026-08-01 ride walked the OLD stop set (example.com, mikelev.in, pipulate.com); what bare `walk` rides
# assets/trails/practice.yaml # one configurable page; UNREAD, label stale since 2026-08-01
# assets/trails/first_context.yaml # profile default; SETTLE real; Jira/Botify/Gmail, THREE wallet kinds in one trail; UNRIDDEN
# assets/trails/botify_pageworkers.yaml # profile botify; SETTLE real; UNRIDDEN -- the only trail on a non-default profile, and no such ride has ever been witnessed
(nix) pipulate $ m
📝 Committing: chore: Update assets/trails/public_walk.yaml to public_walk.json
[main a7afe73e] chore: Update assets/trails/public_walk.yaml to public_walk.json
1 file changed, 1 insertion(+), 1 deletion(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'flake.nix'.
(nix) pipulate $ d
diff --git a/flake.nix b/flake.nix
index 2ffc7d51..eca5a060 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1493,7 +1493,17 @@ runScript = pkgs.writeShellScriptBin "run-script" ''
# A FUNCTION, not an alias, per the release conviction of
# 2026-08-01: an alias body ending in a paren reports a syntax error
# at the trailing argument the operator typed.
- ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$PIPULATE_ROOT/adhocwalk.txt" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
+ # THE WALK ROUTER LIVES BESIDE THE HUMAN ROUTER (convicted 2026-09-16,
+ # two transcripts): mother_cat._write_walk_router derives its target
+ # from PIPULATE_ADHOC_FILE -- default $PIPULATE_ROOT/adhoc.txt -- and
+ # swaps the filename, so a shell that points the variable outside
+ # the worktree gets adhocwalk.txt outside the worktree too. The old
+ # spelling here named $PIPULATE_ROOT/adhocwalk.txt outright, which is
+ # where the file lands only while the variable is UNSET: right on a
+ # fresh Mac install, ROUTER REFUSED on the machine that set it. One
+ # derivation, the writer's, spelled once and read by every word below.
+ _walkrouter() { printf '%s/adhocwalk.txt\n' "$(dirname "''${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")"; }
+ ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
# THE IDEATION DOOR: `idea` compiles IDEATION_CHOP (the constitution's
# two forcing-function rules) primed for a 30-and-3 / axis-forcing
# fan-out turn. A function, not an alias, so --profile/--reason pass
(nix) pipulate $ m
📝 Committing: chore: Refactor `ahcw` function in flake.nix
[main aed8aee5] chore: Refactor `ahcw` function in flake.nix
1 file changed, 11 insertions(+), 1 deletion(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'flake.nix'.
(nix) pipulate $ d
diff --git a/flake.nix b/flake.nix
index eca5a060..eef4db98 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1504,6 +1504,22 @@ runScript = pkgs.writeShellScriptBin "run-script" ''
# derivation, the writer's, spelled once and read by every word below.
_walkrouter() { printf '%s/adhocwalk.txt\n' "$(dirname "''${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")"; }
ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
+ # THE TWO WORDS AFTER THE WALK (proposed 2026-09-16; the names sit
+ # under the coachman's veto, the mechanism does not). walk teaches,
+ # plan edits your itinerary, walk plan rides it -- and then the rider
+ # has written the walk router and the newcomer has no plain word for
+ # what comes next. pick opens that router: pick what rides to the AI,
+ # one path or one `! command` per line. pack "your question" compiles
+ # it, question and all, into the clipboard and a sealed cartridge;
+ # bare pack reads prompt.md if one exists. ahe and ahc are the expert
+ # spellings of the same two moves against adhoc.txt. Both words pass
+ # the ATTRIBUTED-VOICE mechanical test -- a human picks lines and the
+ # compiler packs a payload -- where ask and ship do not: nothing here
+ # asks or ships, a human pastes. FUNCTIONS, per THE THREE-TIER
+ # AMENDMENT: typed by a human, never echoed as a probe; the compile
+ # lane witnesses them in the generated hook text.
+ pick() { (cd "$PIPULATE_ROOT" && nvim "$(_walkrouter)"); }
+ pack() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py "$@" --chop ADHOC_CHOP --no-tree); }
# THE IDEATION DOOR: `idea` compiles IDEATION_CHOP (the constitution's
# two forcing-function rules) primed for a 30-and-3 / axis-forcing
# fan-out turn. A function, not an alias, so --profile/--reason pass
(nix) pipulate $ m
📝 Committing: chore: Update flake.nix with detailed comments and function definitions.
[main cd9b9215] chore: Update flake.nix with detailed comments and function definitions.
1 file changed, 16 insertions(+)
(nix) pipulate $ git push
Enumerating objects: 12, done.
Counting objects: 100% (12/12), done.
Delta compression using up to 48 threads
Compressing objects: 100% (9/9), done.
Writing objects: 100% (9/9), 1.94 KiB | 994.00 KiB/s, done.
Total 9 (delta 6), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (6/6), completed with 3 local objects.
To github.com:pipulate/pipulate.git
63bb95e2..cd9b9215 main -> main
(nix) pipulate $
And we ignite.
(nix) pipulate $ exit
exit
(sys) pipulate $ ndq
And now apparently this:
(nix) pipulate $ _walkrouter
/home/mike/.local/state/pipulate/adhocwalk.txt
(nix) pipulate $ ls -l
total 64600
-rw-r--r-- 1 mike users 2934 Aug 5 10:24 AGENTS.md
-rw-r--r-- 1 mike users 97541 Sep 15 20:29 AI_CONTEXT.md
-rw-r--r-- 1 mike users 16766 Feb 27 2026 AI_RUNME.py
-rw-r--r-- 1 mike users 456021 Jul 13 11:12 allowlist_2026-07.tsv
-rw-r--r-- 1 mike users 456021 Jul 13 11:07 allowlist_new.tsv
-rw-r--r-- 1 mike users 456021 Jul 13 11:12 allowlist.tsv
-rw-r--r-- 1 mike users 33827 Sep 11 17:14 apply.py
drwxr-xr-x 3 mike users 4096 Jul 18 20:39 apps
drwxr-xr-x 14 mike users 4096 Jul 27 13:03 assets
-rw-r--r-- 1 mike users 9706 Jun 6 03:46 AUDIT.md
drwxr-xr-x 41 mike users 4096 Sep 14 05:51 browser_cache
-rw-r--r-- 1 mike users 30290 Sep 5 02:48 cli.py
-rw-r--r-- 1 mike users 16212 Jul 18 20:29 config.py
drwxr-xr-x 12 mike users 4096 Sep 16 06:55 data
-rw-r--r-- 1 mike users 229935 Sep 1 08:41 deleteme2.txt
-rw-r--r-- 1 mike users 29283 Sep 1 17:21 deleteme3.txt
-rw-r--r-- 1 mike users 43077 Sep 1 18:49 deleteme4.txt
-rw-r--r-- 1 mike users 22344 Sep 15 17:34 deleteme.txt
drwxr-xr-x 2 mike users 4096 Mar 12 2026 Deliverables
drwxr-xr-x 2 mike users 4096 Sep 15 20:29 dist
drwxr-xr-x 8 mike users 4096 Apr 29 19:28 downloads
-rw-r--r-- 1 mike users 215294 May 11 2025 favicon.ico
-rw-r--r-- 1 mike users 1497 Jul 21 19:01 flake.lock
-rw-r--r-- 1 mike users 135258 Sep 16 06:55 flake.nix
-rw------- 1 mike users 1167375 Sep 15 16:10 foo-0fa2efda-1409.zip
-rw------- 1 mike users 949004 Sep 15 18:03 foo-19d4e8b8-1414.zip
-rw------- 1 mike users 596232 Sep 15 17:45 foo-2566177b-1412.zip
-rw------- 1 mike users 877666 Sep 16 05:27 foo-37a56f80-1425.zip
-rw------- 1 mike users 1348532 Sep 15 20:03 foo-38b6f9b1-1419.zip
-rw------- 1 mike users 864351 Sep 16 05:47 foo-404397fe-1427.zip
-rw------- 1 mike users 1014328 Sep 15 19:31 foo-584d1508-1418.zip
-rw------- 1 mike users 876477 Sep 16 04:54 foo-6002e92b-1422.zip
-rw------- 1 mike users 807183 Sep 16 04:17 foo-7a03fcf1-1420.zip
-rw------- 1 mike users 1811399 Sep 15 18:41 foo-7e10fbc1-1415.zip
-rw------- 1 mike users 457161 Sep 15 17:09 foo-8f9d4613-1411.zip
-rw------- 1 mike users 876435 Sep 16 04:53 foo-94e09fa2-1421.zip
-rw------- 1 mike users 1621778 Sep 16 06:39 foo-97711f3e-1428.zip
-rw------- 1 mike users 819712 Sep 16 05:21 foo-a70f1912-1424.zip
-rw------- 1 mike users 1050005 Sep 16 05:00 foo-ab91f3c1-1423.zip
-rw------- 1 mike users 905614 Sep 15 19:10 foo-af3cbe4b-1417.zip
-rw------- 1 mike users 1340715 Sep 15 18:49 foo-d3aaadb2-1416.zip
-rw------- 1 mike users 944346 Sep 15 17:55 foo-ded87e39-1413.zip
-rw------- 1 mike users 364845 Sep 15 16:54 foo-e676f5f2-1410.zip
-rw------- 1 mike users 897302 Sep 16 05:33 foo-f30549fc-1426.zip
-rw-r--r-- 1 mike users 321736 Sep 16 06:54 foo_files.py
-rw------- 1 mike users 1621778 Sep 16 06:39 foo.zip
-rw-r--r-- 1 mike users 110033 Sep 14 21:08 GLOSSARY.md
drwxr-xr-x 5 mike users 4096 Aug 6 10:09 imports
-rw-r--r-- 1 mike users 39825 Sep 14 12:38 init.lua
-rw-r--r-- 1 mike users 2886 Sep 15 20:29 __init__.py
-rw-r--r-- 1 mike users 5378834 Jul 9 15:03 jeopardy.wav
-rw-r--r-- 1 mike users 34522 May 8 09:32 LICENSE
drwxr-xr-x 2 mike users 4096 Sep 14 19:15 logs
-rw-r--r-- 1 mike users 313 Jul 12 22:12 MANIFEST.in
-rwxr-xr-x 1 mike users 1730 Sep 13 07:28 nixops.sh
drwxr-xr-x 15 mike users 4096 Aug 31 21:53 Notebooks
-rw-r--r-- 1 mike users 1622 Sep 16 06:55 patch
drwxr-xr-x 3 mike users 4096 Jul 26 07:25 pipulate
drwxr-xr-x 2 mike users 4096 Sep 15 20:29 pipulate.egg-info
-rw-r--r-- 1 mike users 206926 Sep 15 18:13 prompt_foo.py
-rw-r--r-- 1 mike users 13114 Sep 16 06:39 prompt.md
drwxr-xr-x 2 mike users 4096 Sep 16 06:39 __pycache__
-rw-r--r-- 1 mike users 4104 Sep 15 20:29 pyproject.toml
-rw-r--r-- 1 mike users 108293 Sep 5 02:29 README.md
-rw------- 1 mike users 35895162 Jan 1 1980 realkeywords.csv
-rwxr-xr-x 1 mike users 65186 Aug 30 17:40 release.py
drwxr-xr-x 3 mike users 4096 Dec 22 2025 remotes
-rw-r--r-- 1 mike users 2348 Jul 25 17:56 requirements.in
-rw-r--r-- 1 mike users 19966 Jul 25 17:59 requirements.txt
drwxr-xr-x 12 mike users 4096 Sep 10 12:24 scripts
-rw-r--r-- 1 mike users 267986 Sep 15 20:29 server.py
drwxr-xr-x 3 mike users 4096 Aug 21 03:56 tests
drwxr-xr-x 3 mike users 4096 Aug 30 06:57 tools
-rw-r--r-- 1 mike users 3261 Sep 15 19:53 walk
-rw-r--r-- 1 mike users 9 May 3 13:26 whitelabel.txt
(nix) pipulate $ pick
(nix) pipulate $ pack "smoke"
╭─────────────────────────────────────────────── 🐰 ASCII Art Wax Seal (your vibe-coding safety-net) ───────────────────────────────────────────────╮
│ │
│ ( Like a canary you say? ) │
│ O /) ____ The "No Problem" Framework │
│ > I HEREBY WILL NOT RE-GENERATE o /)\__// / \ Pipulate - Protecting Your Code │
│ > Once upon machines be smarten ___(/_ 0 0 | | just by being honest about text. │
│ > ASCII sealing immutata art in *( ==(_T_)== NPvg | (If mangled, then AI drifted.) │
│ > This here cony if it's broken \ ) ""\ | | https://pipulate.com │
│ > Smokin gun drift now in token |__>-\_>_> \____/ 🥕🥕🥕 │
│ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
🗺️ Codex Mapping Coverage: 74.0% (202/273 tracked files).
ROUTER LOADED: /home/mike/.local/state/pipulate/adhocwalk.txt (1 active line(s))
✅ Topological Integrity Verified: 2 candidate reference(s) scanned, all exist.
-> Ruff exit 0 (clean).
📦 Payload Ledger (biggest first)
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━┓
┃ File / Source ┃ Tokens ┃ Bytes ┃ % Bytes ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━┩
│ data/captures/walk-y8inhn1w/captures.md │ 371,754 │ 1,003,048 │ 95.3% │
│ apply.py │ 7,844 │ 33,827 │ 3.2% │
│ PROMPT (checklist + prompt.md) │ 2,507 │ 11,201 │ 1.1% │
│ .gitignore │ 970 │ 3,598 │ 0.3% │
│ AUTO: Recent Git Diff Telemetry │ 222 │ 695 │ 0.1% │
│ .gitattributes │ 33 │ 76 │ 0.0% │
│ AUTO: Static Analysis Diagnostics │ 11 │ 39 │ 0.0% │
├─────────────────────────────────────────┼─────────┼───────────┼─────────┤
│ TOTAL │ 383,341 │ 1,052,484 │ 100.0% │
└─────────────────────────────────────────┴─────────┴───────────┴─────────┘
**Command:** `prompt_foo.py smoke --chop ADHOC_CHOP --no-tree`
--- Auto-Context Metadata ---
• Static Analysis Diagnostics (11 tokens | 39 bytes)
• Recent Git Diff Telemetry (222 tokens | 695 bytes)
--- Prompt Summary ---
Summed Tokens: 385,073 (from section parts)
Verified Tokens: 386,059 (from final output)
(Difference: +986)
Total Words: 59,722 (content only)
Total Chars: 1,061,243
Total Bytes: 1,061,436 (UTF-8)
--- Size Perspective ---
📚 Equivalent in length to a **Average Paperback Novel or a Ph.D. Dissertation** (Note: With a token/word ratio of 6.46, this content is far denser and more complex than typical prose of this length).
🧼 Identity scrub: substitutions=57 rule(s) | denylist=0 rule(s)
🔎 Render canary: 1 bare www-token(s) exposed to autolinking: www.npvg.org
🔐 Secrets tripwire: ARMED — 0 hit(s) in payload.
📦 Canonical context cartridge written to /home/mike/repos/pipulate/foo.zip (sha256=9eda557d259f…, members=3)
🗂️ Rotated cartridge snapshot: foo-9eda557d-1429.zip (keeping newest 20 of 20)
Markdown output copied to clipboard
(nix) pipulate $
Wow, that looks good and right. But ahcw is wayyy to much. Those “expert
spellings” are way too complicated for New-B. We can’t use anything that needs a
constant reminder or glossary. I want to say: “Now you edit that. And then you
compile that.” And I think better aliases that help train them are:
- ahew to
eprfor “Edit Prompt Router” - ahcw to
cprfor “Compile Prompt Router”
I’ll be able to remember this because Sci-Fi/Science it’s the same name as the
non-locality paper ha ha! And then to resuscitate a dying prompting process you
perform CPR, see? It’s a bit different than the ahe, ahc symmetry in that it
puts the verb at the beginning versus the end but I think that’s fine. We always
want to frame the discussion in that you’ve got a “prompt router” (pr) that’s
got to be edited first and then compiled. So the command to edit your prompt
router is “epr” and the command to compile your prompt router is “cpr”. We want
it both memorable with easy associations to other things and language so
appreciated yet spot-on verbatim about what it does that it defuses all this
other future nonsense that’s liable to come up for which sticking to as
literal-as possible is often the best strategy.
4: Prompt: Continue THE TWO WORDS AFTER THE WALK. Read this compile’s Manifest-listed live receipts first.
Last turn proposed three cars: (1) foo_files.py chapter VIII-b roster line public_walk.yaml -> public_walk.json; (2) flake.nix: a helper deriving the walk router’s path beside the human router, the same derivation mother_cat._write_walk_router uses, with ahcw reading it; (3) flake.nix: pick (open the walk router in nvim) and pack “question” (compile it through ADHOC_CHOP with the question as the prompt). Expected: the rg census on foo_files.py shows the roster line reading .json and, in the compile lane, the Paintbox row gone (3 lines by hand, 2 in the compile); the quiet hook parses with walkrouter_lines 0 -> 4 (0 -> 2 if car 3 was vetoed); the ls census names which of the two candidate walk-router paths exists on this machine and reads the same before and after by design. Ignition for cars 2-3 was exit then ndq. Treat pick and pack as witnessed only from my operator report below, never from the hook count.
Then the pivot proper, three decisions, each its own car with its own probe, in this order. (a) The router the walk writes names captures.md, the whole unsanitized archive, and compiling that line is the context explosion the newcomer is being spared; decide whether _write_walk_router names data/decant-preview.md as the active line when DECANT was authorized and keeps the archive path as a commented drill-down line, and whether that write moves after _complete_preview or a second write follows it, given that the current order exists so a router failure cannot block DECANT. (b) scripts/boot_menu.py DOOR_TWO_WORDS gains pick and pack so the door-2 list does not omit them. (c) Whether the connector aliases (jira, email/gmail, botify, confluence, slack, sheets, gsc) become writeShellScriptBin packages in the shape aiCommitCommand already uses, aliases deleted so there is one spelling, so that ! jira SWCX-1234 is a legal router line under the ! executor per THE THREE-TIER AMENDMENT; if that car is too wide for the window, say so and name the long spelling the newcomer types instead.
Keep the promise language: inspectable, never hallucination-free; re-derive the analysis from the archive, re-run the capture from the trail. Do not start the Botify SpeedWorkers work.
Operator report:
Terminal transcript:
5: Deliverables: A process that can absolutely be demonstrated on the Mac today and start being useful today for my day-job for the exact “Fantasy League” Jira ticket-closing I need to do. This is all about something that can all be committed to muscle memory from a cold start easily. All the “do this, then do that” is minimized because Nix can let you pin hard-wired paths on a generic normalized local Linux you hardly even need to know you have because it’s doing its WORA thing so well. Nix wears WORA well.
Take it from here, Fable 5.1! We’re almost out of time so no big refactors; just lightweight dot-connecting.
Fable 5.1 Extra: Context verified, with one ruling before anything else. The Manifest says this compile read a twenty-line router: the article-era Context 5 plus the dismount’s SEED lines. The Context 7 you pasted did not run. flake.nix and scripts/boot_menu.py are not in this payload, and none of last turn’s three probes has a compile-lane AFTER here. THE STALE OVERLAY, ruled from the receipts. What this compile does witness: foo_files.py’s roster line reads public_walk.json (Car 1 landed; the working-tree diff is the Paintbox catching up one line), and the operator lane witnessed Cars 2 and 3 directly, _walkrouter printing the state-dir path and pack "smoke" loading that same path. The integrity alert naming public_walk.yaml comes from the commented Context 1-4 lines in the router this compile read; your pasted file has pruned them, so it clears the moment that file is the one compiled.
Then the smoke’s own receipt, which decides (a) without argument: captures.md rode at 371,754 tokens, 95.3% of the payload, and the identity scrub fired 57 substitutions on a walk of three public pages. The preview those same captures produced passed 0/0/0 at DECANT. The router names the wrong file.
epr and cpr
Taken as ruled. pick, pack and ahcw go; epr edits the prompt router and cpr compiles it, and the comment says what the words say and nothing cleverer. ahe and ahc stay as the same two moves against adhoc.txt for whoever already types them. epr takes EDITOR, then nvim, then vim, then vi: plan hardcodes nvim, the Mac transcript never typed plan, and an editor the flake does not pin is a fact about the host, not the flake.
One consequence is load-bearing and it is not a rename. THE HANDOFF paragraph in foo_files.py says a hand-typed ! line belongs in adhoc.txt because the rider writes adhocwalk.txt WHOLE on every completed run: it replaces, it never merges. pick invited hand-typed lines into that file last turn and epr inherits the invitation, so the demo flow, walk, epr, add the Jira line, walk plan for a second capture on the same ticket, loses the Jira line without a word. The cure is one guard in the writer: it replaces only a file it could have written, one uncommented absolute path to an archive or a preview and nothing else. Any other uncommented line means a human owns the file; the rider prints the new path lines for them and touches nothing, and deleting the file lets the next walk rewrite it. THE SUCCESS-ONLY WITNESS in reverse: the world where the human edited the file must print something different from the world where they did not.
(a) The preview rides
Two writes, not one moved write. The first stays where it is, at archive completion, so a partial run, a declined DECANT or a blocked check still leaves a router naming the archive, labelled. The second happens inside _decant_to_clipboard, directly after _write_decant_preview returns, which is the only line in the file where the preview is known to exist on disk; there it rewrites the router with the preview as the one uncommented line and the archive as a commented line beneath, one uncomment away for the drill-down. The handoff boolean is never consulted because it cannot be trusted for this: _decant_to_clipboard returns True after a failed preview write and a successful clipboard attempt, completion not being delivery. So archive_path threads through _complete_preview and _decant_checkpoint as a keyword defaulting to None, and both writes stay wrapped, so neither can block DECANT or the clipboard.
The header the newcomer reads when epr opens the file does the teaching: one line per thing the AI should see, a path or a command after ! , edit freely, an edited router is never replaced.
(b) and (c)
(b) waits for scripts/boot_menu.py to ride; two words join DOOR_TWO_WORDS, and whatever prints “Five words to start from” is a hand-counted ordinal that goes stale on the sixth word, the same defect the trail guidance carried. (c) is too wide for this window and I will not pretend otherwise: seven writeShellScriptBin entries, seven aliases deleted, the sources roster re-read. Until then the router line a newcomer types is the long spelling, and it works in every lane the executor has: ! .venv/bin/python scripts/connectors/jira.py SWCX-1234.
The loop on the Mac today
Two entries, because the first nix develop runs the old hook, which pulls these commits, and only the second runs the hook it pulled. Then door 2, walk, 2, CAPTURE three times; the router lands at ~/npvg/adhocwalk.txt there, naming the preview. warm jira once if the ticket needs it. epr, add the Jira line and anything else the ticket cites. cpr "What does this ticket need to close?" fills the clipboard and rotates a sealed zip; paste it. The reply ends in a train; patch, app, run the probes, cpr again. deed the zip that closes it and attach it to the ticket. Three words carry the newcomer’s whole day: walk, epr, cpr.
One line of housekeeping from your ls -l, not for this turn: four deleteme files and a 35 MB realkeywords.csv sit in the repo root, and the .gitignore’s own comment says what that means.
1. PROBES
The router probe is the writer’s straddle in the compile lane, no walk needed: it points PIPULATE_ADHOC_FILE at a temp dir, imports the rider, writes an archive line, tries a preview line, then appends a relative path as a human would and writes again. Before: preview=no_kwarg guard=REPLACED, the old writer having no keyword and overwriting the edit. After: preview=rides guard=KEPT. The hook probe evaluates the flake on disk, so it needs no re-entry; old_words counts ahcw/pick/pack definitions, new_words counts epr/cpr: 3/0 before, 0/2 after, and quiet_hook_syntax=ok is a gate on both sides. The ahcw census is a label sweep: foo_files.py’s three hits go to zero, any flake.nix survivors are comment lines above _walkrouter that this compile could not see, and GLOSSARY.md or init.lua hits name their own car. The public_walk census closes last turn’s straddle: the 2026-08-01 prose line and the .json roster line, two lines, no Paintbox row. The router cat is an ACTUATION-BOUNDARY straddle: it moves only if a walk completes between taps, from the four-line captures.md router to a five-line one with the preview uncommented; the same reading before and after means no walk ran, not a broken seam. By hand after the walk, cat "$(_walkrouter)" reads the same file.
.venv/bin/python -B -c 'exec("import os, sys, tempfile\nfrom pathlib import Path\nd = tempfile.mkdtemp()\nos.environ[\"PIPULATE_ADHOC_FILE\"] = d + \"/adhoc.txt\"\nsys.path.insert(0, \"scripts\")\nimport mother_cat as m\na, p = \"/tmp/x/captures.md\", \"/tmp/x/decant-preview.md\"\nr = m._write_walk_router(a)\nlive = lambda: [l for l in r.read_text().splitlines() if l.strip() and not l.startswith(\"#\")]\ntry:\n m._write_walk_router(a, preview_path=p)\n preview = \"rides\" if live() == [p] and (\"# \" + a) in r.read_text() else \"wrong\"\nexcept TypeError:\n preview = \"no_kwarg\"\nr.write_text(r.read_text() + \"foo_files.py\\n\")\ntry:\n m._write_walk_router(a)\n guard = \"REPLACED\"\nexcept ValueError:\n guard = \"KEPT\" if \"foo_files.py\" in r.read_text() else \"lost\"\nprint(\"router_probe preview=%s guard=%s\" % (preview, guard))\n")'
bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok old_words=%s new_words=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(ahcw|pick|pack)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)"'
rg -nw ahcw flake.nix foo_files.py GLOSSARY.md init.lua | sort | head -20
rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
2. NEXT CONTEXT
The four files the next turn edits or sweeps, and nothing from the article era. Make this the file ahc reads; the Manifest will say whether it was.
# Context 8 (epr, cpr, the preview rides)
foo_files.py
flake.nix
scripts/boot_menu.py
scripts/mother_cat.py
! .venv/bin/python -B -c 'exec("import os, sys, tempfile\nfrom pathlib import Path\nd = tempfile.mkdtemp()\nos.environ[\"PIPULATE_ADHOC_FILE\"] = d + \"/adhoc.txt\"\nsys.path.insert(0, \"scripts\")\nimport mother_cat as m\na, p = \"/tmp/x/captures.md\", \"/tmp/x/decant-preview.md\"\nr = m._write_walk_router(a)\nlive = lambda: [l for l in r.read_text().splitlines() if l.strip() and not l.startswith(\"#\")]\ntry:\n m._write_walk_router(a, preview_path=p)\n preview = \"rides\" if live() == [p] and (\"# \" + a) in r.read_text() else \"wrong\"\nexcept TypeError:\n preview = \"no_kwarg\"\nr.write_text(r.read_text() + \"foo_files.py\\n\")\ntry:\n m._write_walk_router(a)\n guard = \"REPLACED\"\nexcept ValueError:\n guard = \"KEPT\" if \"foo_files.py\" in r.read_text() else \"lost\"\nprint(\"router_probe preview=%s guard=%s\" % (preview, guard))\n")'
! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok old_words=%s new_words=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(ahcw|pick|pack)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)"'
! rg -nw ahcw flake.nix foo_files.py GLOSSARY.md init.lua | sort | head -20
! rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
! cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
3. PATCHES
Car 1, flake.nix: the two words. flake.nix did not ride this compile, so the SEARCH is quoted from the d receipt in your own transcript, which shows the lines Car 3 landed byte for byte. The exact-match interlock is the fence: a refusal costs one rerun with flake.nix in context and changes nothing. The comment above _walkrouter that introduced ahcw is outside what I can see; the census probe reads it, and the next compile sweeps it.
Target: flake.nix
[[[SEARCH]]]
ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
# THE TWO WORDS AFTER THE WALK (proposed 2026-09-16; the names sit
# under the coachman's veto, the mechanism does not). walk teaches,
# plan edits your itinerary, walk plan rides it -- and then the rider
# has written the walk router and the newcomer has no plain word for
# what comes next. pick opens that router: pick what rides to the AI,
# one path or one `! command` per line. pack "your question" compiles
# it, question and all, into the clipboard and a sealed cartridge;
# bare pack reads prompt.md if one exists. ahe and ahc are the expert
# spellings of the same two moves against adhoc.txt. Both words pass
# the ATTRIBUTED-VOICE mechanical test -- a human picks lines and the
# compiler packs a payload -- where ask and ship do not: nothing here
# asks or ships, a human pastes. FUNCTIONS, per THE THREE-TIER
# AMENDMENT: typed by a human, never echoed as a probe; the compile
# lane witnesses them in the generated hook text.
pick() { (cd "$PIPULATE_ROOT" && nvim "$(_walkrouter)"); }
pack() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py "$@" --chop ADHOC_CHOP --no-tree); }
[[[DIVIDER]]]
# THE PROMPT ROUTER HAS TWO WORDS (2026-09-16, the operator's ruling;
# the first names rode for one turn and are gone). The walk writes the
# prompt router; epr Edits the Prompt Router; cpr Compiles the Prompt
# Router. Literal on purpose: a newcomer is told "edit that, then
# compile that" and the words say exactly that; the mnemonics (the
# non-locality paper, resuscitation) cost nothing. ahe and ahc are the
# same two moves against adhoc.txt for whoever already types them.
# cpr "your question" compiles the router with that question as the
# prompt; bare cpr reads prompt.md, exactly as ahc does. FUNCTIONS, per
# THE THREE-TIER AMENDMENT: typed by a human, never echoed as a probe;
# the compile lane witnesses them in the generated hook text. epr takes
# EDITOR, then nvim, then vim, then vi, so a machine with no nvim still
# opens the file.
epr() { (cd "$PIPULATE_ROOT" && "''${EDITOR:-$(command -v nvim || command -v vim || echo vi)}" "$(_walkrouter)"); }
cpr() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py "$@" --chop ADHOC_CHOP --no-tree); }
[[[REPLACE]]]
Car 2, scripts/mother_cat.py: the router names the preview and yields to a human. Eleven small blocks, one story: the walk router became the newcomer’s file.
Target: scripts/mother_cat.py
[[[SEARCH]]]
def _write_walk_router(archive_path):
"""Replace one local selection; never read, disclose or compile its evidence."""
[[[DIVIDER]]]
def _router_line(path, what):
"""One absolute path as one router line, or refuse: the grammar has no escapes."""
text = str(path)
if (not Path(text).is_absolute() or text.splitlines() != [text]
or "#" in text or "<--" in text):
raise ValueError(f"{what} path cannot be represented as one router file line")
return text
def _write_walk_router(archive_path, preview_path=None):
"""Replace one local selection; never read, disclose or compile its evidence.
THE ROUTER IS THE NEWCOMER'S FILE (2026-09-16): `epr` opens it, so it is
replaced ONLY while it is a file this writer could have produced -- one
uncommented absolute path to an archive or a preview and nothing else. Any
other uncommented line is a human's; the new paths are printed for them
and nothing is touched. With a preview, the preview is the line that rides
and the archive is a commented line beneath it; without one, the archive
rides alone, labelled UNSANITIZED.
"""
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
source = str(archive_path)
# The existing router grammar has no escape for these separators.
if (not Path(source).is_absolute() or source.splitlines() != [source]
or "#" in source or "<--" in source):
raise ValueError("capture path cannot be represented as one router file line")
[[[DIVIDER]]]
source = _router_line(archive_path, "capture")
preview = None if preview_path is None else _router_line(preview_path, "preview")
# REPLACE ONLY A FILE THIS WRITER COULD HAVE WRITTEN: one uncommented
# absolute path to an archive or a preview, and nothing else. Any other
# uncommented line is a human's, so the paths are printed for them instead.
if target.is_file():
owned = [line.strip() for line in target.read_text(encoding="utf-8").splitlines()
if line.strip() and not line.lstrip().startswith("#")]
if owned and (len(owned) != 1 or not owned[0].startswith("/")
or not owned[0].endswith(("captures.md", "decant-preview.md"))):
raise ValueError(
"hand-edited router kept, nothing written; add the line(s) yourself: "
+ " ".join(line for line in (preview, source) if line)
+ " (or delete the file and the next walk rewrites it)")
head = (
"# Written by the last completed walk. Edit freely: an edited router is never replaced.\n"
"# One line per thing the AI should see: a file path, or a command after `! `.\n"
)
if preview:
body = (
"# The checked preview rides. The whole UNSANITIZED archive is the commented line beneath it.\n"
f"{preview}\n"
f"# {source}\n"
)
else:
body = (
"# No checked preview was saved, so this is the whole UNSANITIZED archive. Review before compiling.\n"
f"{source}\n"
)
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
stream.write(
"# Generated: last completed nonempty capture run.\n"
"# Replaced on completion; partial or empty runs leave this selection unchanged.\n"
"# UNSANITIZED local evidence; review before disclosure or compilation.\n"
f"{source}\n"
)
[[[DIVIDER]]]
stream.write(head + body)
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
print(f" WALK ROUTER NOT UPDATED ({type(exc).__name__}): {exc}")
print(" Archive preserved; any prior adhocwalk.txt still selects an earlier run.")
else:
print(f" WALK ROUTER {target} (0600; UNSANITIZED; not compiled)")
[[[DIVIDER]]]
print(f" WALK ROUTER NOT UPDATED ({type(exc).__name__}): {exc}")
print(" Archive preserved; the router on disk is unchanged.")
else:
print(f" WALK ROUTER {target} (0600; names the UNSANITIZED archive until a preview is released)")
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
def _decant_checkpoint(payload, captured):
[[[DIVIDER]]]
def _decant_checkpoint(payload, captured, archive_path=None):
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
"before the preview-file and clipboard attempts."
)
return _decant_to_clipboard(payload)
[[[DIVIDER]]]
"before the preview-file and clipboard attempts."
)
return _decant_to_clipboard(payload, archive_path=archive_path)
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
def _complete_preview(payload, captured, intro=False):
"""Use explicit introductory authorization, or the existing manual gate."""
if not intro:
return _decant_checkpoint(payload, captured)
[[[DIVIDER]]]
def _complete_preview(payload, captured, intro=False, archive_path=None):
"""Use explicit introductory authorization, or the existing manual gate."""
if not intro:
return _decant_checkpoint(payload, captured, archive_path=archive_path)
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
print("\nChecking the summary before saving it and trying the clipboard.")
return _decant_to_clipboard(payload)
[[[DIVIDER]]]
print("\nChecking the summary before saving it and trying the clipboard.")
return _decant_to_clipboard(payload, archive_path=archive_path)
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
def _decant_to_clipboard(payload):
[[[DIVIDER]]]
def _decant_to_clipboard(payload, archive_path=None):
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
else:
digest = hashlib.sha256(scrubbed.encode("utf-8")).hexdigest()
print(f" LOCAL PREVIEW {target} (0600; sha256={digest})")
copy_to_clipboard(scrubbed)
return True
[[[DIVIDER]]]
else:
digest = hashlib.sha256(scrubbed.encode("utf-8")).hexdigest()
print(f" LOCAL PREVIEW {target} (0600; sha256={digest})")
# The router names the preview only once the preview exists on disk:
# written here, after the file, never inferred from a handoff boolean.
if archive_path is not None:
try:
router = _write_walk_router(archive_path, preview_path=target)
except Exception as exc:
print(f" WALK ROUTER NOT UPDATED ({type(exc).__name__}): {exc}")
else:
print(f" WALK ROUTER {router} (0600; the preview rides, the archive is commented beneath it)")
copy_to_clipboard(scrubbed)
return True
[[[REPLACE]]]
Target: scripts/mother_cat.py
[[[SEARCH]]]
decanted = _complete_preview(payload, captured, intro=intro)
[[[DIVIDER]]]
decanted = _complete_preview(payload, captured, intro=intro, archive_path=archive["path"])
[[[REPLACE]]]
Car 3, foo_files.py: the labels follow the flake and the rider. The first block is a mid-line anchor, so the roster’s padding column is never reproduced.
Target: foo_files.py
[[[SEARCH]]]
(adhocwalk.txt through `ahcw`) into a payload
[[[DIVIDER]]]
(adhocwalk.txt: `epr` edits it, `cpr` compiles it) into a payload
[[[REPLACE]]]
Target: foo_files.py
[[[SEARCH]]]
# Selection: adhocwalk.txt names one raw captures.md and labels it UNSANITIZED;
[[[DIVIDER]]]
# Selection: adhocwalk.txt names the checked preview and, commented beneath it, the raw captures.md;
[[[REPLACE]]]
Target: foo_files.py
[[[SEARCH]]]
# THE HANDOFF (97feb327): a complete, nonempty run has the rider write
# adhocwalk.txt WHOLE beside the selected router -- three comment lines and one
# absolute path, 0600, os.replace'd. IT REPLACES, IT NEVER MERGES, so a
# hand-typed `!` line belongs in adhoc.txt, the file `ahcw` deliberately does
# not select; the seam between the two is a copy. Riding from a shell where
# PIPULATE_ADHOC_FILE already names adhocwalk.txt refuses by name, non-fatally,
# archive preserved, which is why ahcw assigns in a subshell rather than
# exporting. SELECTING IS NOT INCLUDING: naming adhocwalk.txt inside another
# list includes its text and never recurses into its entries.
[[[DIVIDER]]]
# THE HANDOFF (97feb327; amended 2026-09-16): a complete, nonempty run has the
# rider write adhocwalk.txt WHOLE beside the selected router, 0600,
# os.replace'd -- the checked preview as the one uncommented line once DECANT
# released it, the whole archive as a commented line beneath, and the archive
# alone, labelled, when no preview was saved. IT REPLACES, IT NEVER MERGES, and
# because `epr` now invites a hand-typed `!` line into this very file, it
# REPLACES ONLY A FILE IT COULD HAVE WRITTEN: one uncommented absolute path to
# an archive or a preview and nothing else. Any other uncommented line means a
# human owns the file; the rider prints the new path lines and touches nothing,
# and deleting the file lets the next walk rewrite it. Riding from a shell where
# PIPULATE_ADHOC_FILE already names adhocwalk.txt refuses by name, non-fatally,
# archive preserved, which is why cpr assigns in a subshell rather than
# exporting. SELECTING IS NOT INCLUDING: naming adhocwalk.txt inside another
# list includes its text and never recurses into its entries.
[[[REPLACE]]]
Ignition. Car 1: exit then ndq; the hook probe reads the flake on disk and needs no re-entry, but the words at your prompt do, so after re-entry type epr, quit, then cpr "smoke" and read ROUTER LOADED for the state-dir path. Car 2: the router probe imports the patched writer at call time, so the writer’s three branches self-ignite; the seam, the rider handing the preview to the writer, ignites only with a real ride, walk, 2, CAPTURE three times, after which the router cat should read the preview uncommented and the archive commented beneath it. Car 3: no ignition required.
4. PROMPT
Continue THE PROMPT ROUTER HAS TWO WORDS. Read this compile's Manifest-listed live receipts first, and confirm this compile carried flake.nix, scripts/boot_menu.py and scripts/mother_cat.py; the previous compile read a stale router and carried none of the three probes, so rule from the Manifest if the pasted context disagrees with it again.
Last turn proposed three cars, in this order. (1) flake.nix: ahcw, pick and pack deleted; epr (open the walk router in EDITOR, else nvim, vim, vi) and cpr (compile it through ADHOC_CHOP, a positional as the prompt, bare reads prompt.md) defined beside _walkrouter; ignition exit then ndq. (2) scripts/mother_cat.py: _write_walk_router takes preview_path and, when given one, writes the preview as the one uncommented line with the archive commented beneath; it refuses, non-fatally, to replace a file carrying any uncommented line other than one absolute path to an archive or a preview; _decant_to_clipboard rewrites the router directly after _write_decant_preview succeeds, with archive_path threaded through _complete_preview and _decant_checkpoint as a keyword defaulting to None; the writer self-ignites under the probe, the seam ignites only with a real walk. (3) foo_files.py: the HANDOFF paragraph, the Selection line and the HAND OFF roster line follow the flake and the rider; no ignition.
Expected LIVE RECEIPTS: router_probe preview=no_kwarg guard=REPLACED -> preview=rides guard=KEPT; quiet_hook_syntax=ok old_words=3 new_words=0 -> old_words=0 new_words=2; the ahcw census reads three foo_files.py lines -> none, any surviving flake.nix hits being comment lines above _walkrouter that this compile can now sweep in one car, and any GLOSSARY.md or init.lua hits named for their own; the public_walk census on foo_files.py reads the 2026-08-01 prose line and the .json roster line and nothing else. The router cat moves ONLY if a walk completed between taps: if the LIVE RECEIPT still shows the four-line captures.md router, no walk ran and the seam is unwitnessed, not broken. Treat epr and cpr as witnessed only from my operator report below, never from the hook count.
Then, each its own car: (b) scripts/boot_menu.py DOOR_TWO_WORDS gains epr and cpr, and whatever prints "Five words to start from" stops hand-counting the words; (c) stays deferred unless the window allows it: the connector aliases as writeShellScriptBin packages so `! jira SWCX-1234` is a legal router line under the ! executor per THE THREE-TIER AMENDMENT, and until then the newcomer's line is `! .venv/bin/python scripts/connectors/jira.py SWCX-1234`. Keep the promise language: inspectable, never hallucination-free; re-derive the analysis from the archive, re-run the capture from the trail. Do not start the Botify SpeedWorkers work.
Operator report:
Terminal transcript:
5. EXTERNAL DELIVERABLES
No external deliverables this turn. The Mac card above is prose for a human, not cargo for a foreign system.
MikeLev.in:
Same commands, run twice, one change between them. Where the readings differ is what the change did; the diff in the middle is the receipt.
1: Probe: (BEFORE: hand-run, nothing changed yet)
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ .venv/bin/python -B -c 'exec("import os, sys, tempfile\nfrom pathlib import Path\nd = tempfile.mkdtemp()\nos.environ[\"PIPULATE_ADHOC_FILE\"] = d + \"/adhoc.txt\"\nsys.path.insert(0, \"scripts\")\nimport mother_cat as m\na, p = \"/tmp/x/captures.md\", \"/tmp/x/decant-preview.md\"\nr = m._write_walk_router(a)\nlive = lambda: [l for l in r.read_text().splitlines() if l.strip() and not l.startswith(\"#\")]\ntry:\n m._write_walk_router(a, preview_path=p)\n preview = \"rides\" if live() == [p] and (\"# \" + a) in r.read_text() else \"wrong\"\nexcept TypeError:\n preview = \"no_kwarg\"\nr.write_text(r.read_text() + \"foo_files.py\\n\")\ntry:\n m._write_walk_router(a)\n guard = \"REPLACED\"\nexcept ValueError:\n guard = \"KEPT\" if \"foo_files.py\" in r.read_text() else \"lost\"\nprint(\"router_probe preview=%s guard=%s\" % (preview, guard))\n")'
bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok old_words=%s new_words=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(ahcw|pick|pack)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)"'
rg -nw ahcw flake.nix foo_files.py GLOSSARY.md init.lua | sort | head -20
rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
router_probe preview=no_kwarg guard=REPLACED
quiet_hook_syntax=ok old_words=3 new_words=0
flake.nix:1506: ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
foo_files.py:1665:# prompt_foo.py # <-- Compiles the selected router (adhocwalk.txt through `ahcw`) into a payload
foo_files.py:1700:# hand-typed `!` line belongs in adhoc.txt, the file `ahcw` deliberately does
foo_files.py:1703:# archive preserved, which is why ahcw assigns in a subshell rather than
744:# FIRST WALKTHROUGH SHIPPED 2026-08-01: assets/trails/public_walk.yaml rode
1671:# assets/trails/public_walk.json # profile default; SETTLE trivial; three unlinked npvg.org pages (the_word, the_receipt, the_two_pages), inline script on stop three only, connector noop.py; RIDDEN 2026-09-15 on these stops, 3 of 3 at artifacts=11 each, archive complete, DECANT AUTHORIZED at 20,992 B with checks 0/0/0, and the chatbot given stop three's question said the preview does not carry the server's sentence, which is true (the diff-lens TODO); the 2026-08-01 ride walked the OLD stop set (example.com, mikelev.in, pipulate.com); what bare `walk` rides
# Generated: last completed nonempty capture run.
# Replaced on completion; partial or empty runs leave this selection unchanged.
# UNSANITIZED local evidence; review before disclosure or compilation.
/home/mike/repos/pipulate/data/captures/walk-y8inhn1w/captures.md
(nix) pipulate $
2: Context: (AFTER: the same probes re-run by the compiler as ! lines)
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | Fixing command names.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | |
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# To Human: WELCOME TO VIM! It's really NeoVim but I say vim anyway.
# To AI: This is an alternate 40K view to the big book-ore rolling pin spine.
# 1. **Probe**: Baseline Reading
# 2. **Context**: Post-experiment *planned* reading instructions
# 3. **Patch**: The experiment and how to make it happen
# 4. **Prompt**: Post-experiment instructions and how to read results
# 5. **Deliverable**: How the world is forever different moving forward
# The first thing you need to know here is that everything that comes after the
# hash symbol (#) is commented out — and that's EVERYTHING in this file's default
# state. Begin editing-in lines for inclusion as part of the context or adding
# chunks of new context at the bottom. `Ctrl`+`v`, `j` (repeatedly), `l` (to move
# right), `d` (to delete). Reverse that with `Ctrl`+`v`, `j` (repeatedly),
# `Shift`+`i`, `# `, `Esc` to put the hashes back. You can just arrow-key around
# here with `h`, `j`, `k`, `l`. Save-and-quit is a bit tricky because another
# file is also loaded: `Esc`, `:`, `q`, `w`, `!`
# If this is stressing you out and you're a quitter and want to quit, just type:
# `Esc`, `:`, `q`, `!`, `Enter`. That will exit without saving any changes. If
# you want to get over this hump, type: `Esc`, `:`, `T`, `u`, `t`, `o`, `r`, `Enter`.
# This file is just to make it easy having options of what to edit into context.
# You can use whatever text-file you want to stack file-names and commands to
# build an output text-file with the identically stacked output of each file or
# command. In this way we vertically append or "stack" a bunch of text; simple as
# that. If you understand this concept, you're on your way to future-proofing
# yourself in the Age of AI. Congratulations! Here is how to include web pages:
# !URL --------------------------------------------------------------------
# when Public page; what a stranger or crawler sees; the BEFORE of a
# login-wall diagnosis
# switch It shows a login page -> `warm URL` once, then `?URL`
#
# ?URL --------------------------------------------------------------------
# when Anything behind a login, on the site's persistent profile;
# `check URL` first
# switch The lenses show a shell (nav, an `[Iframe]` leaf, no content) ->
# read the wire truth for the XHR the frame makes, then call that
# API with a connector
#
# @URL --------------------------------------------------------------------
# when Every re-read of a page already scraped; no browser, no network
# switch The cached page is stale or was a login wall -> fresh `!` or `?`
#
# $URL --------------------------------------------------------------------
# when Exact markup: meta tags, a JSON blob in a `<script>`
# note Token-heavy; needs a prior scrape
#
# %URL --------------------------------------------------------------------
# when The network log distilled; SPA endpoint discovery
# switch It re-serves the wire truth you already have -> the API
#
# ! cmd -------------------------------------------------------------------
# when Any bounded, non-interactive command as a live receipt
# note Cap it with `-n`; no aliases, no prompts
#
# Connector ---------------------------------------------------------------
# when The number you want is one GET away
# switch LIST until the thing isn't in the list -> FETCH by id -> DRILL
# the path the app's own frame called -> `--grep` to narrow a list
# or find a leaf
# Every step is one argument longer than the last; the moment a lens shows less than the wire does is the moment to stop scraping.
# FOR 40K-FT VIEW (STORY & INFRASTRUCTURE)
# --- START EDITING-IN ON 1ST TURN ---
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- ROLLING PIN that gives the 40K foot book-spine view of book-ore (only works for me because of local-only git repo)
# ~/repos/nixos/autognome.py # <-- You wake up in the morning and your Tooling & Instrumentation folds out of you like Inspector Gadget.
# init.lua # <-- Those gadgets are made easy-to-use through nifty keyboard shortcuts (but ya gotta learn vim).
# GLOSSARY.md # <-- Like the back of a J.R.R. Tolkien book, there's kooky new terms to know.
# flake.nix # <-- Here is my hardware. Here is my state. Put on your sandbox. And please recreate. (Infrastructure as Code / IaC)
# prompt_foo.py # <-- THIS system
# foo_files.py # <-- main ROUTER
# requirements.in # <-- We've "pinned" everything but still want a flexible Python Data Science virtualenv.
# pyproject.toml # <-- How this is a citizen of the Python "pip install" ecosystem
# __init__.py # <-- Version info
# --- END EDITING-IN ON 1ST TURN ---
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# OPTIONAL ACTUATORS (cheap and good to include to expand the AI's capabilities)
# cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
# scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
# scripts/crawl.py # <-- Feel free to ask for something to be crawled and included in the next turn.
# scripts/weblogin.py # <-- Lets the user "warm up" the cache for their web logins at their leisure on a profile that persists.
# scripts/webclip_2_markdown.py # <-- Surprisingly important program.
# MISCELLANEOUS (rare to include but sometimes critical)
# scripts/foo_cartridge.py # Needs description
# scripts/foo_replay.py # Needs description
# release.py # <-- How everything ends up where it does (GitHub, PyPI, etc.)
# imports/voice_synthesis.py # <-- The wand can talk to you
# imports/ascii_displays.py # <-- Where all the ASCII Art lives
# scripts/release/version_sync.py # <-- Needs to be wrapped into release.py and eliminated, I think.
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
# Carry-over as the important work-in-progress parts of the project here just
# like above but not as long-standing overarching to the framework but rather
# for the current hot spots actively being worked on.
# STICKBUG & MOTHER CAT KATA (WORKING ON THE CHAPTER)
# Always include these with whatever connector
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# scripts/connectors/confluence.py
# scripts/connectors/gmail.py
# scripts/connectors/gsc.py
# scripts/connectors/jira.py
# scripts/connectors/mcp.py
# scripts/connectors/mcp_warm.py
# scripts/connectors/sheets.py
# scripts/connectors/slack.py
# --- START THIS DISCUSSION ---
# Get things started here! Guess at what context should be included.
# If you get it wrong, you're just wasting 1-turn because the AI will help.
# Un-comment lines, add lines with absolute-path filenames or `! ` commands.
# Context 1
# foo_files.py
# walk
# assets/installer/mck.sh
# scripts/mother_cat.py
# scripts/walk.py
# scripts/walk_cartridge.py
# imports/voice_synthesis.py
# tools/scraper_tools.py
# prompt_foo.py
# assets/trails/public_walk.yaml
# Context 2
# foo_files.py
# walk
# assets/installer/mck.sh
# scripts/mother_cat.py
# scripts/walk.py
# scripts/walk_cartridge.py
# imports/voice_synthesis.py
# tools/scraper_tools.py
# prompt_foo.py
# assets/trails/public_walk.yaml
# ! .venv/bin/python -B -c 'exec("import ast, contextlib, io\nfrom pathlib import Path\np = Path(\"scripts/mother_cat.py\")\nf = next(n for n in ast.parse(p.read_text()).body if isinstance(n, ast.AsyncFunctionDef) and n.name == \"_ride_steps\")\nassert isinstance(f.body[-2], ast.If) and ast.unparse(f.body[-2].test) == \"captured\"\ntail = compile(ast.Module(body=f.body[-2].body, type_ignores=[]), str(p), \"exec\")\nfor intro, handoff in ((True, True), (True, False), (False, True), (False, False)):\n calls = []\n ns = dict(intro=intro, captured=[], archive={\"previews\": []}, skipped=[], disclosed=True, _decant=lambda *a: \"fixture\", _complete_preview=lambda *a, **k: handoff, _narrate=lambda *a: calls.append(a))\n with contextlib.redirect_stdout(io.StringIO()):\n exec(tail, ns)\n assert len(calls) <= int(intro)\n if calls:\n assert calls[0][1] is True and ((\"withheld\" in calls[0][0]) == (not handoff))\n assert \"saved\" not in calls[0][0] and \"copied\" not in calls[0][0]\n print(\"intro=%s handoff=%s closing=%s\" % (intro, handoff, len(calls)))\n")'
# flake.nix
# init.lua
# Context 3
# foo_files.py
# walk
# assets/installer/mck.sh
# scripts/mother_cat.py
# scripts/walk.py
# scripts/walk_cartridge.py
# assets/trails/public_walk.yaml
# flake.nix
# ! .venv/bin/python -B -c 'import ast,json; from pathlib import Path; t=ast.parse(Path("scripts/mother_cat.py").read_text()); names={n.name for n in t.body if isinstance(n,ast.FunctionDef)}; print("private_plan_helpers="+str(len(names & {"_private_plan_path","_edit_private_plan"}))); d=json.loads(Path("assets/trails/public_walk.yaml").read_text()); print("public_stops="+str(len(d["stops"]))); conflicts=[p for lane in ("Notebooks/Playground/trails","Notebooks/Shared/trails","assets/trails") if (p:=Path(lane)/"plan.yaml").exists()]; assert not conflicts,"plan is already a name in an existing trail lane"; print("plan_name_conflicts=0")'
# ! bash -n assets/installer/mck.sh && printf 'launcher_syntax=ok\n'
# ! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "%s\n" "$hook" | .venv/bin/python -B -c "import sys; lines=sys.stdin.read().splitlines(); print(\"quiet_hook_syntax=ok plan_aliases=\"+str(sum(line.strip().startswith(\"alias plan=\") for line in lines)))"'
# Context 4
# foo_files.py
# walk
# assets/installer/mck.sh
# scripts/mother_cat.py
# scripts/walk.py
# scripts/walk_cartridge.py
# assets/trails/public_walk.yaml
# flake.nix
# ! rg -n --glob '!foo_files.py' --glob '!prompt.md' --glob '!data/**' 'public_walk\.yaml|\.yaml|JSON subset of YAML|json\.loads' walk assets/installer scripts flake.nix | head -80
# ! .venv/bin/python -B scripts/walk.py --trail assets/trails/public_walk.yaml >/dev/null && printf 'planner_current_format=ok\n'
# scripts/walk_compile.py
# Context 5
# foo_files.py
# walk
# assets/installer/mck.sh
# scripts/mother_cat.py
# scripts/walk.py
# scripts/walk_compile.py
# scripts/walk_cartridge.py
# assets/trails/public_walk.json
# ! .venv/bin/python -B -c 'from pathlib import Path; from scripts import walk; c=[Path("assets/trails/public_walk.yaml"),Path("assets/trails/public_walk.json")]; p=[x for x in c if x.exists()]; assert len(p)==1,p; t=walk.load_trail(p[0]); s=Path("scripts/walk_compile.py").read_text(); print("canonical="+p[0].name+" default="+walk.DEFAULT_TRAIL.name+" stops="+str(len(t["stops"]))+" compiler_json="+str('\''stem + ".json"'\'' in s))'
# ! bash -n assets/installer/mck.sh && printf 'launcher_syntax=ok\n'
# ! rg -n 'public_walk\.(yaml|json)|plan\.(yaml|json)|<stem>\.(yaml|json)' assets/installer/mck.sh scripts/mother_cat.py scripts/walk.py scripts/walk_compile.py scripts/walk_cartridge.py | head -60
# Content 1
# /home/mike/repos/trimnoir/_posts/2026-09-16-walk-plan-run-replayable-workflows.md # [Idx: 1475 | Order: 1 | Tokens: 41,920 | Bytes: 166,717]
# foo_files.py
# cli.py
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# ! .venv/bin/python cli.py mcp-discover
# ! .venv/bin/python scripts/connectors/botify.py --help | head -80
# Context 2
# Context 8 (epr, cpr, the preview rides)
foo_files.py
flake.nix
scripts/boot_menu.py
scripts/mother_cat.py
! .venv/bin/python -B -c 'exec("import os, sys, tempfile\nfrom pathlib import Path\nd = tempfile.mkdtemp()\nos.environ[\"PIPULATE_ADHOC_FILE\"] = d + \"/adhoc.txt\"\nsys.path.insert(0, \"scripts\")\nimport mother_cat as m\na, p = \"/tmp/x/captures.md\", \"/tmp/x/decant-preview.md\"\nr = m._write_walk_router(a)\nlive = lambda: [l for l in r.read_text().splitlines() if l.strip() and not l.startswith(\"#\")]\ntry:\n m._write_walk_router(a, preview_path=p)\n preview = \"rides\" if live() == [p] and (\"# \" + a) in r.read_text() else \"wrong\"\nexcept TypeError:\n preview = \"no_kwarg\"\nr.write_text(r.read_text() + \"foo_files.py\\n\")\ntry:\n m._write_walk_router(a)\n guard = \"REPLACED\"\nexcept ValueError:\n guard = \"KEPT\" if \"foo_files.py\" in r.read_text() else \"lost\"\nprint(\"router_probe preview=%s guard=%s\" % (preview, guard))\n")'
! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok old_words=%s new_words=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(ahcw|pick|pack)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)"'
! rg -nw ahcw flake.nix foo_files.py GLOSSARY.md init.lua | sort | head -20
! rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
! cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
# --- END `adhoc.txt` TEMPLATE ---
3: Patches: (the one change between the readings)
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'flake.nix'.
(nix) pipulate $ d
diff --git a/flake.nix b/flake.nix
index eef4db98..190d6dee 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1503,23 +1503,21 @@ runScript = pkgs.writeShellScriptBin "run-script" ''
# fresh Mac install, ROUTER REFUSED on the machine that set it. One
# derivation, the writer's, spelled once and read by every word below.
_walkrouter() { printf '%s/adhocwalk.txt\n' "$(dirname "''${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")"; }
- ahcw() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py --chop ADHOC_CHOP --no-tree "$@"); }
- # THE TWO WORDS AFTER THE WALK (proposed 2026-09-16; the names sit
- # under the coachman's veto, the mechanism does not). walk teaches,
- # plan edits your itinerary, walk plan rides it -- and then the rider
- # has written the walk router and the newcomer has no plain word for
- # what comes next. pick opens that router: pick what rides to the AI,
- # one path or one `! command` per line. pack "your question" compiles
- # it, question and all, into the clipboard and a sealed cartridge;
- # bare pack reads prompt.md if one exists. ahe and ahc are the expert
- # spellings of the same two moves against adhoc.txt. Both words pass
- # the ATTRIBUTED-VOICE mechanical test -- a human picks lines and the
- # compiler packs a payload -- where ask and ship do not: nothing here
- # asks or ships, a human pastes. FUNCTIONS, per THE THREE-TIER
- # AMENDMENT: typed by a human, never echoed as a probe; the compile
- # lane witnesses them in the generated hook text.
- pick() { (cd "$PIPULATE_ROOT" && nvim "$(_walkrouter)"); }
- pack() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py "$@" --chop ADHOC_CHOP --no-tree); }
+ # THE PROMPT ROUTER HAS TWO WORDS (2026-09-16, the operator's ruling;
+ # the first names rode for one turn and are gone). The walk writes the
+ # prompt router; epr Edits the Prompt Router; cpr Compiles the Prompt
+ # Router. Literal on purpose: a newcomer is told "edit that, then
+ # compile that" and the words say exactly that; the mnemonics (the
+ # non-locality paper, resuscitation) cost nothing. ahe and ahc are the
+ # same two moves against adhoc.txt for whoever already types them.
+ # cpr "your question" compiles the router with that question as the
+ # prompt; bare cpr reads prompt.md, exactly as ahc does. FUNCTIONS, per
+ # THE THREE-TIER AMENDMENT: typed by a human, never echoed as a probe;
+ # the compile lane witnesses them in the generated hook text. epr takes
+ # EDITOR, then nvim, then vim, then vi, so a machine with no nvim still
+ # opens the file.
+ epr() { (cd "$PIPULATE_ROOT" && "''${EDITOR:-$(command -v nvim || command -v vim || echo vi)}" "$(_walkrouter)"); }
+ cpr() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py "$@" --chop ADHOC_CHOP --no-tree); }
# THE IDEATION DOOR: `idea` compiles IDEATION_CHOP (the constitution's
# two forcing-function rules) primed for a 30-and-3 / axis-forcing
# fan-out turn. A function, not an alias, so --profile/--reason pass
(nix) pipulate $ m
📝 Committing: chore: Update prompt router definitions in flake.nix
[main 244a5558] chore: Update prompt router definitions in flake.nix
1 file changed, 15 insertions(+), 17 deletions(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/mother_cat.py'.
(nix) pipulate $ d
diff --git a/scripts/mother_cat.py b/scripts/mother_cat.py
index 0a750608..c7f80c81 100644
--- a/scripts/mother_cat.py
+++ b/scripts/mother_cat.py
@@ -296,8 +296,26 @@ def _bank_capture(archive, trail, index, stop, params, result):
return problems
-def _write_walk_router(archive_path):
- """Replace one local selection; never read, disclose or compile its evidence."""
+def _router_line(path, what):
+ """One absolute path as one router line, or refuse: the grammar has no escapes."""
+ text = str(path)
+ if (not Path(text).is_absolute() or text.splitlines() != [text]
+ or "#" in text or "<--" in text):
+ raise ValueError(f"{what} path cannot be represented as one router file line")
+ return text
+
+
+def _write_walk_router(archive_path, preview_path=None):
+ """Replace one local selection; never read, disclose or compile its evidence.
+
+ THE ROUTER IS THE NEWCOMER'S FILE (2026-09-16): `epr` opens it, so it is
+ replaced ONLY while it is a file this writer could have produced -- one
+ uncommented absolute path to an archive or a preview and nothing else. Any
+ other uncommented line is a human's; the new paths are printed for them
+ and nothing is touched. With a preview, the preview is the line that rides
+ and the archive is a commented line beneath it; without one, the archive
+ rides alone, labelled UNSANITIZED.
+ """
selected = os.environ.get("PIPULATE_ADHOC_FILE", str(REPO_ROOT / "adhoc.txt"))
if not selected.strip():
raise ValueError("PIPULATE_ADHOC_FILE is empty")
@@ -309,11 +327,35 @@ def _write_walk_router(archive_path):
if (target.is_symlink() or target.resolve() == human.resolve()
or (target.exists() and human.exists() and target.samefile(human))):
raise ValueError("walk router aliases the human router or is a symlink")
- source = str(archive_path)
- # The existing router grammar has no escape for these separators.
- if (not Path(source).is_absolute() or source.splitlines() != [source]
- or "#" in source or "<--" in source):
- raise ValueError("capture path cannot be represented as one router file line")
+ source = _router_line(archive_path, "capture")
+ preview = None if preview_path is None else _router_line(preview_path, "preview")
+ # REPLACE ONLY A FILE THIS WRITER COULD HAVE WRITTEN: one uncommented
+ # absolute path to an archive or a preview, and nothing else. Any other
+ # uncommented line is a human's, so the paths are printed for them instead.
+ if target.is_file():
+ owned = [line.strip() for line in target.read_text(encoding="utf-8").splitlines()
+ if line.strip() and not line.lstrip().startswith("#")]
+ if owned and (len(owned) != 1 or not owned[0].startswith("/")
+ or not owned[0].endswith(("captures.md", "decant-preview.md"))):
+ raise ValueError(
+ "hand-edited router kept, nothing written; add the line(s) yourself: "
+ + " ".join(line for line in (preview, source) if line)
+ + " (or delete the file and the next walk rewrites it)")
+ head = (
+ "# Written by the last completed walk. Edit freely: an edited router is never replaced.\n"
+ "# One line per thing the AI should see: a file path, or a command after `! `.\n"
+ )
+ if preview:
+ body = (
+ "# The checked preview rides. The whole UNSANITIZED archive is the commented line beneath it.\n"
+ f"{preview}\n"
+ f"# {source}\n"
+ )
+ else:
+ body = (
+ "# No checked preview was saved, so this is the whole UNSANITIZED archive. Review before compiling.\n"
+ f"{source}\n"
+ )
temp = None
try:
with tempfile.NamedTemporaryFile(
@@ -322,12 +364,7 @@ def _write_walk_router(archive_path):
) as stream:
temp = Path(stream.name)
os.fchmod(stream.fileno(), 0o600)
- stream.write(
- "# Generated: last completed nonempty capture run.\n"
- "# Replaced on completion; partial or empty runs leave this selection unchanged.\n"
- "# UNSANITIZED local evidence; review before disclosure or compilation.\n"
- f"{source}\n"
- )
+ stream.write(head + body)
stream.flush()
os.fsync(stream.fileno())
os.replace(temp, target)
@@ -356,9 +393,9 @@ def _finish_capture_archive(archive, status, skipped=()):
target = _write_walk_router(archive["path"])
except Exception as exc:
print(f" WALK ROUTER NOT UPDATED ({type(exc).__name__}): {exc}")
- print(" Archive preserved; any prior adhocwalk.txt still selects an earlier run.")
+ print(" Archive preserved; the router on disk is unchanged.")
else:
- print(f" WALK ROUTER {target} (0600; UNSANITIZED; not compiled)")
+ print(f" WALK ROUTER {target} (0600; names the UNSANITIZED archive until a preview is released)")
else:
print(" WALK ROUTER unchanged: this run did not complete with captures.")
print(" Any existing adhocwalk.txt still selects an earlier completed run.")
@@ -424,7 +461,7 @@ def _print_artifact_homes(captured):
print(f" {stop_name}: (no artifact paths recorded)")
for home in homes:
print(f" {stop_name}: {home}")
-def _decant_checkpoint(payload, captured):
+def _decant_checkpoint(payload, captured, archive_path=None):
"""Refuse to release the bundle until a human types DECANT. Returns bool.
THE ARMED LINE IS UNCONDITIONAL AND IT IS THE POINT. An armed gate that
@@ -491,17 +528,17 @@ def _decant_checkpoint(payload, captured):
f"\n AUTHORIZED by human: checking {payload_bytes:,} assembled bytes "
"before the preview-file and clipboard attempts."
)
- return _decant_to_clipboard(payload)
-def _complete_preview(payload, captured, intro=False):
+ return _decant_to_clipboard(payload, archive_path=archive_path)
+def _complete_preview(payload, captured, intro=False, archive_path=None):
"""Use explicit introductory authorization, or the existing manual gate."""
if not intro:
- return _decant_checkpoint(payload, captured)
+ return _decant_checkpoint(payload, captured, archive_path=archive_path)
if tuple(final_url for _, final_url, _ in captured) != INTRO_URLS:
print(" BLOCKED: the walk left its three public pages. Summary not sent.")
print(" The local captures remain; any older summary is unchanged.")
return False
print("\nChecking the summary before saving it and trying the clipboard.")
- return _decant_to_clipboard(payload)
+ return _decant_to_clipboard(payload, archive_path=archive_path)
def _write_decant_preview(payload):
@@ -527,7 +564,7 @@ def _write_decant_preview(payload):
return target
-def _decant_to_clipboard(payload):
+def _decant_to_clipboard(payload, archive_path=None):
"""Check once, save locally, then attempt the existing clipboard handoff.
Deferred import: prompt_foo drags tiktoken/pydot in at module load, so it is
@@ -553,6 +590,15 @@ def _decant_to_clipboard(payload):
else:
digest = hashlib.sha256(scrubbed.encode("utf-8")).hexdigest()
print(f" LOCAL PREVIEW {target} (0600; sha256={digest})")
+ # The router names the preview only once the preview exists on disk:
+ # written here, after the file, never inferred from a handoff boolean.
+ if archive_path is not None:
+ try:
+ router = _write_walk_router(archive_path, preview_path=target)
+ except Exception as exc:
+ print(f" WALK ROUTER NOT UPDATED ({type(exc).__name__}): {exc}")
+ else:
+ print(f" WALK ROUTER {router} (0600; the preview rides, the archive is commented beneath it)")
copy_to_clipboard(scrubbed)
return True
@@ -930,7 +976,7 @@ async def _ride_steps(trail_path, archive, dry_narrate=False, exports_path=None,
print("\nRide complete. Every stop produced a capture receipt.")
if captured:
payload = _decant(captured, archive["previews"], skipped)
- decanted = _complete_preview(payload, captured, intro=intro)
+ decanted = _complete_preview(payload, captured, intro=intro, archive_path=archive["path"])
# ATTRIBUTED-VOICE, fixed in passing because these are the exact lines
# being rewritten: the old text asserted "copied to your clipboard"
# UNCONDITIONALLY, one statement after calling a function that swallows
(nix) pipulate $ m
📝 Committing: refactor: rename `_write_walk_router` to `_router_line` and add type checking for router lines
[main 6b10c419] refactor: rename `_write_walk_router` to `_router_line` and add type checking for router lines
1 file changed, 68 insertions(+), 22 deletions(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'foo_files.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'foo_files.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'foo_files.py'.
(nix) pipulate $ d
diff --git a/foo_files.py b/foo_files.py
index e7d7ab0b..3c9eb116 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -1662,7 +1662,7 @@ __init__.py # <-- Version info
# imports/voice_synthesis.py # <-- Piper: scripted narration, never a model (ATTRIBUTED-VOICE)
#
# HAND OFF
-# prompt_foo.py # <-- Compiles the selected router (adhocwalk.txt through `ahcw`) into a payload
+# prompt_foo.py # <-- Compiles the selected router (adhocwalk.txt: `epr` edits it, `cpr` compiles it) into a payload
# scripts/foo_cartridge.py # <-- The second seal, over the EVIDENCE: payload.md, prompt.md, manifest.json
# scripts/foo_replay.py # <-- Context extraction and attention checks; not browser or API replay
# tests/test_mck_rep2.py # <-- Rep 2: the earmark's owed side-by-side witness
@@ -1691,16 +1691,21 @@ __init__.py # <-- Version info
# network body. Preview: DECANT releases selected, capped text, never the raw
# archive. Disclosure: captures.disclosed.json is a separately prepared
# derivative with omissions and review status; nothing writes it for you.
-# Selection: adhocwalk.txt names one raw captures.md and labels it UNSANITIZED;
+# Selection: adhocwalk.txt names the checked preview and, commented beneath it, the raw captures.md;
# the list is neither disclosure approval nor the evidence.
#
-# THE HANDOFF (97feb327): a complete, nonempty run has the rider write
-# adhocwalk.txt WHOLE beside the selected router -- three comment lines and one
-# absolute path, 0600, os.replace'd. IT REPLACES, IT NEVER MERGES, so a
-# hand-typed `!` line belongs in adhoc.txt, the file `ahcw` deliberately does
-# not select; the seam between the two is a copy. Riding from a shell where
+# THE HANDOFF (97feb327; amended 2026-09-16): a complete, nonempty run has the
+# rider write adhocwalk.txt WHOLE beside the selected router, 0600,
+# os.replace'd -- the checked preview as the one uncommented line once DECANT
+# released it, the whole archive as a commented line beneath, and the archive
+# alone, labelled, when no preview was saved. IT REPLACES, IT NEVER MERGES, and
+# because `epr` now invites a hand-typed `!` line into this very file, it
+# REPLACES ONLY A FILE IT COULD HAVE WRITTEN: one uncommented absolute path to
+# an archive or a preview and nothing else. Any other uncommented line means a
+# human owns the file; the rider prints the new path lines and touches nothing,
+# and deleting the file lets the next walk rewrite it. Riding from a shell where
# PIPULATE_ADHOC_FILE already names adhocwalk.txt refuses by name, non-fatally,
-# archive preserved, which is why ahcw assigns in a subshell rather than
+# archive preserved, which is why cpr assigns in a subshell rather than
# exporting. SELECTING IS NOT INCLUDING: naming adhocwalk.txt inside another
# list includes its text and never recurses into its entries.
#
(nix) pipulate $ m
📝 Committing: chore: Update adhocwalk.txt description and usage notes
[main 48f2e8bc] chore: Update adhocwalk.txt description and usage notes
1 file changed, 13 insertions(+), 8 deletions(-)
(nix) pipulate $ git push
Enumerating objects: 15, done.
Counting objects: 100% (15/15), done.
Delta compression using up to 48 threads
Compressing objects: 100% (10/10), done.
Writing objects: 100% (10/10), 3.42 KiB | 3.42 MiB/s, done.
Total 10 (delta 7), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (7/7), completed with 5 local objects.
To github.com:pipulate/pipulate.git
331a25c6..48f2e8bc main -> main
(nix) pipulate $
And we ignite:
(nix) pipulate $ g
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ exit
exit
(sys) pipulate $ ndq
(nix) pipulate $ epr
(nix) pipulate $ cpr "smoke"
╭─────────────────────────────────────────────── 🐰 ASCII Art Wax Seal (your vibe-coding safety-net) ───────────────────────────────────────────────╮
│ │
│ ( Like a canary you say? ) │
│ O /) ____ The "No Problem" Framework │
│ > I HEREBY WILL NOT RE-GENERATE o /)\__// / \ Pipulate - Protecting Your Code │
│ > Once upon machines be smarten ___(/_ 0 0 | | just by being honest about text. │
│ > ASCII sealing immutata art in *( ==(_T_)== NPvg | (If mangled, then AI drifted.) │
│ > This here cony if it's broken \ ) ""\ | | https://pipulate.com │
│ > Smokin gun drift now in token |__>-\_>_> \____/ 🥕🥕🥕 │
│ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
🗺️ Codex Mapping Coverage: 74.0% (202/273 tracked files).
ROUTER LOADED: /home/mike/.local/state/pipulate/adhocwalk.txt (1 active line(s))
✅ Topological Integrity Verified: 2 candidate reference(s) scanned, all exist.
-> Ruff exit 0 (clean).
📦 Payload Ledger (biggest first)
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━┓
┃ File / Source ┃ Tokens ┃ Bytes ┃ % Bytes ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━┩
│ data/captures/walk-y8inhn1w/captures.md │ 371,754 │ 1,003,048 │ 95.1% │
│ apply.py │ 7,844 │ 33,827 │ 3.2% │
│ PROMPT (checklist + prompt.md) │ 2,507 │ 11,201 │ 1.1% │
│ .gitignore │ 970 │ 3,598 │ 0.3% │
│ AUTO: Recent Git Diff Telemetry │ 767 │ 2,961 │ 0.3% │
│ .gitattributes │ 33 │ 76 │ 0.0% │
│ AUTO: Static Analysis Diagnostics │ 11 │ 39 │ 0.0% │
├─────────────────────────────────────────┼─────────┼───────────┼─────────┤
│ TOTAL │ 383,886 │ 1,054,750 │ 100.0% │
└─────────────────────────────────────────┴─────────┴───────────┴─────────┘
**Command:** `prompt_foo.py smoke --chop ADHOC_CHOP --no-tree`
--- Auto-Context Metadata ---
• Static Analysis Diagnostics (11 tokens | 39 bytes)
• Recent Git Diff Telemetry (767 tokens | 2,961 bytes)
--- Prompt Summary ---
Summed Tokens: 385,620 (from section parts)
Verified Tokens: 386,606 (from final output)
(Difference: +986)
Total Words: 60,090 (content only)
Total Chars: 1,063,511
Total Bytes: 1,063,704 (UTF-8)
--- Size Perspective ---
📚 Equivalent in length to a **Average Paperback Novel or a Ph.D. Dissertation** (Note: With a token/word ratio of 6.43, this content is far denser and more complex than typical prose of this length).
🧼 Identity scrub: substitutions=57 rule(s) | denylist=0 rule(s)
🔎 Render canary: 1 bare www-token(s) exposed to autolinking: www.npvg.org
🔐 Secrets tripwire: ARMED — 0 hit(s) in payload.
📦 Canonical context cartridge written to /home/mike/repos/pipulate/foo.zip (sha256=65ba81302136…, members=3)
🗂️ Rotated cartridge snapshot: foo-65ba8130-1432.zip (keeping newest 20 of 20)
Markdown output copied to clipboard
(nix) pipulate $
Okay, but I can’t tell a New-B to use the “smoke” parameter. Think how much
explaining is needed there! It should be exactly like the ahe, ahc symmetry.
It’s hard enough to get a New-B through even that (they’re going to have to
learn vim!). Let’s get rid of the need for “smoke” if we can. It’s always
those same file names being edited and compiled. Let’s just do this one last
thing and then we’ll wrap this. It’s 7:30 AM already.
4: Prompt: Continue THE PROMPT ROUTER HAS TWO WORDS. Read this compile’s Manifest-listed live receipts first, and confirm this compile carried flake.nix, scripts/boot_menu.py and scripts/mother_cat.py; the previous compile read a stale router and carried none of the three probes, so rule from the Manifest if the pasted context disagrees with it again.
Last turn proposed three cars, in this order. (1) flake.nix: ahcw, pick and pack deleted; epr (open the walk router in EDITOR, else nvim, vim, vi) and cpr (compile it through ADHOC_CHOP, a positional as the prompt, bare reads prompt.md) defined beside _walkrouter; ignition exit then ndq. (2) scripts/mother_cat.py: _write_walk_router takes preview_path and, when given one, writes the preview as the one uncommented line with the archive commented beneath; it refuses, non-fatally, to replace a file carrying any uncommented line other than one absolute path to an archive or a preview; _decant_to_clipboard rewrites the router directly after _write_decant_preview succeeds, with archive_path threaded through _complete_preview and _decant_checkpoint as a keyword defaulting to None; the writer self-ignites under the probe, the seam ignites only with a real walk. (3) foo_files.py: the HANDOFF paragraph, the Selection line and the HAND OFF roster line follow the flake and the rider; no ignition.
Expected LIVE RECEIPTS: router_probe preview=no_kwarg guard=REPLACED -> preview=rides guard=KEPT; quiet_hook_syntax=ok old_words=3 new_words=0 -> old_words=0 new_words=2; the ahcw census reads three foo_files.py lines -> none, any surviving flake.nix hits being comment lines above _walkrouter that this compile can now sweep in one car, and any GLOSSARY.md or init.lua hits named for their own; the public_walk census on foo_files.py reads the 2026-08-01 prose line and the .json roster line and nothing else. The router cat moves ONLY if a walk completed between taps: if the LIVE RECEIPT still shows the four-line captures.md router, no walk ran and the seam is unwitnessed, not broken. Treat epr and cpr as witnessed only from my operator report below, never from the hook count.
Then, each its own car: (b) scripts/boot_menu.py DOOR_TWO_WORDS gains epr and cpr, and whatever prints “Five words to start from” stops hand-counting the words; (c) stays deferred unless the window allows it: the connector aliases as writeShellScriptBin packages so ! jira SWCX-1234 is a legal router line under the ! executor per THE THREE-TIER AMENDMENT, and until then the newcomer’s line is ! .venv/bin/python scripts/connectors/jira.py SWCX-1234. Keep the promise language: inspectable, never hallucination-free; re-derive the analysis from the archive, re-run the capture from the trail. Do not start the Botify SpeedWorkers work.
Operator report:
Terminal transcript:
5: Deliverables: This article and the simplest possible process after this turn.
Fable 5.1 Extra: Context verified. This compile carried flake.nix, scripts/boot_menu.py and scripts/mother_cat.py, and the Context 8 router ran (nine active lines), so the stale-overlay ruling from last turn does not repeat. Every straddle landed: router_probe preview=rides guard=KEPT, old_words=0 new_words=2 with the hook parsing, the ahcw census reading zero across all four files (the comment above _walkrouter never named it, so there is nothing to sweep), and the public_walk census reading exactly the 2026-08-01 prose line and the .json roster line. The router cat still reads the four-line captures.md router, which is the predicted no-walk reading: the seam is unwitnessed, not broken, and the cpr "smoke" ledger at 371,754 tokens is the same fact from the other side. The integrity alert naming public_walk.yaml comes from the commented Context 1 through 4 blocks still in your adhoc.txt; delete those blocks and it clears.
The word “smoke” was mine
Bare cpr already does what bare ahc does: no positional, so prompt_foo.py reads prompt.md. The argument was the probe’s, put there so ROUTER LOADED would print without a prompt.md in the way, and I handed it to you as the ignition spelling. Nobody’s spelling is cpr "smoke".
The real gap for a newcomer is one step earlier: where the question gets written. Your muscle memory is the clipboard word prompt, and a stranger has neither the habit nor a prompt.md. So epr opens two files in one split, the way ahe opens two: the prompt router on top, prompt.md beneath it. Add lines above, Ctrl-W j, type the question below, :wqa, then cpr. The flag -o is vi-family, so the editor chain stays nvim, vim, vi and EDITOR drops out; the flake pins no editor, which your Mac’s working vim alias (it is alias vim='nvim') says is fine there today.
(b) rides now
boot_menu.py is in context and its count is derived from the tuple, so adding two rows moves “Five words” to “Seven words” with no hand-counted ordinal anywhere. Seven is the last count _COUNT_WORDS spells; an eighth word prints a digit, which is why plan does not join today and rides the dangling list. epr and cpr sit directly after walk on the scope ladder, because they are what comes after the walk.
The loop, final form
On the Mac: cd ~/npvg && nix develop twice, the first entry pulling these commits and the second running the hook it pulled; door 2. walk, 2, CAPTURE three times; the router now names the preview with the archive commented beneath it. epr: top window, add ! .venv/bin/python scripts/connectors/jira.py SWCX-1234 (after warm jira once if the board is cold); Ctrl-W j; bottom window, the question; :wqa. cpr: clipboard and a sealed zip. Paste. Three words: walk, epr, cpr.
1. PROBES
The hook probe keeps its gate and gains the reading that moves: epr_opens_prompt counts an epr() definition line that names prompt.md, 0 before and 1 after, with new_words holding at 2. The recall probe prints the door-2 list the way menu does, before the isatty gate, so it is a clean compile-lane witness: “Five words to start from” and five rows before, “Seven words” and seven rows after, epr and cpr second and third. The prompt_foo census reads how the positional defaults when prompt.md is absent, a question this compile cannot answer because the file is not in it; it reads the same on both sides and its number rules whether a fresh install’s first bare cpr refuses or proceeds. The router cat is the same ACTUATION-BOUNDARY straddle as last turn: it moves only if a walk completes between taps, and by hand after the walk cat "$(_walkrouter)" reads the same file. The router probe retires, witnessed.
bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
.venv/bin/python scripts/boot_menu.py --recall
rg -n 'prompt\.md' prompt_foo.py | head -20
cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
2. NEXT CONTEXT
Prune the commented Context 1 through 5 blocks while you are in the file; they carry the # assets/trails/public_walk.yaml lines the checker keeps reading.
# Context 9 (epr opens two, the door knows two)
foo_files.py
flake.nix
scripts/boot_menu.py
! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
! .venv/bin/python scripts/boot_menu.py --recall
! rg -n 'prompt\.md' prompt_foo.py | head -20
! cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
3. PATCHES
Car 1, flake.nix: epr opens the router and prompt.md in one split, and the comment says what bare cpr reads.
Target: flake.nix
[[[SEARCH]]]
# the compile lane witnesses them in the generated hook text. epr takes
# EDITOR, then nvim, then vim, then vi, so a machine with no nvim still
# opens the file.
epr() { (cd "$PIPULATE_ROOT" && "''${EDITOR:-$(command -v nvim || command -v vim || echo vi)}" "$(_walkrouter)"); }
[[[DIVIDER]]]
# the compile lane witnesses them in the generated hook text. epr opens
# TWO files in one split, the way ahe opens two: the prompt router on
# top and prompt.md beneath it, the question's home, so a newcomer
# never needs the clipboard word `prompt`. Ctrl-W j moves down, :wqa
# saves both. Bare cpr reads that prompt.md exactly as bare ahc does;
# the positional (cpr "smoke") exists for probes and is nobody's
# spelling. nvim, then vim, then vi: -o is a vi-family flag, so EDITOR
# is not consulted here, and the flake pins no editor at all.
epr() { (cd "$PIPULATE_ROOT" && "$(command -v nvim || command -v vim || echo vi)" -o "$(_walkrouter)" "$PIPULATE_ROOT/prompt.md"); }
[[[REPLACE]]]
Car 2, scripts/boot_menu.py: the door-2 list gains the two words, and the docstring and the ladder comment move with it.
Target: scripts/boot_menu.py
[[[SEARCH]]]
[2] Text Commands NOTHING starts; `walk`, `sources`, `brief`, `pu`, `menu` wait at the prompt
[[[DIVIDER]]]
[2] Text Commands NOTHING starts; `walk`, `epr`, `cpr`, `sources`, `brief`, `pu`, `menu` wait at the prompt
[[[REPLACE]]]
Target: scripts/boot_menu.py
[[[SEARCH]]]
# ORDER IS A SCOPE LADDER, neither alphabetical nor arbitrary: be carried
# (walk) -> look around here yourself (sources) -> hand it to someone
# elsewhere (brief) -> reverse the choice you just made (pu). `walk` leads
# because it is the only row that asks nothing of you first. `menu` rides
[[[DIVIDER]]]
# ORDER IS A SCOPE LADDER, neither alphabetical nor arbitrary: be carried
# (walk) -> edit what the walk wrote (epr) -> compile it for an AI (cpr) ->
# look around here yourself (sources) -> hand it to someone elsewhere
# (brief) -> reverse the choice you just made (pu). `walk` leads because it
# is the only row that asks nothing of you first. `menu` rides
[[[REPLACE]]]
Target: scripts/boot_menu.py
[[[SEARCH]]]
("walk", "take the guided tour -- public pages, nothing to log into"),
("sources", "see what this shell can reach outside this machine"),
[[[DIVIDER]]]
("walk", "take the guided tour -- public pages, nothing to log into"),
# epr and cpr joined 2026-09-16: the two words after the walk. Seven is
# the last count _COUNT_WORDS spells; an eighth word prints a digit.
("epr", "edit the prompt router -- the list the walk wrote of what an AI should see, and your question"),
("cpr", "compile the prompt router into your clipboard -- paste it into an AI"),
("sources", "see what this shell can reach outside this machine"),
[[[REPLACE]]]
Ignition. Car 1: exit then ndq; the hook probe reads the flake on disk and needs no re-entry, but the split at your prompt does: epr should open two windows, the router above and an empty prompt.md below; :wqa out, then bare cpr should print ROUTER LOADED for the state-dir path with no argument typed. Car 2: the recall probe runs the file at call time, so it self-ignites; at the prompt, menu prints the seven-word list, and the threshold copy prints only on a full nix develop, since the quiet shell skips runScript. The seam from last turn still ignites only with a walk, walk, 2, CAPTURE three times, after which the router cat reads the preview uncommented; the Mac demo is that witness if this machine does not get to it first.
4. PROMPT
Continue THE PROMPT ROUTER HAS TWO WORDS, and expect the dismount to follow this turn. Read this compile's Manifest-listed live receipts first.
Last turn proposed two cars. (1) flake.nix: epr opens the prompt router and prompt.md in one vi split (nvim, vim, vi; EDITOR dropped because -o is vi-family), and the comment states that bare cpr reads prompt.md exactly as bare ahc does, the positional having been a probe's argument; ignition exit then ndq. (2) scripts/boot_menu.py: DOOR_TWO_WORDS gains epr and cpr directly after walk, the docstring and the ladder comment moved with them, and the count stays derived; no ignition for the recall probe.
Expected LIVE RECEIPTS: quiet_hook_syntax=ok new_words=2 epr_opens_prompt=0 -> epr_opens_prompt=1 with new_words holding at 2; the recall probe reads "Five words to start from" and five rows -> "Seven words to start from" and seven rows with epr second and cpr third. The prompt_foo census is a CENSUS: it reads the same on both sides, and its lines rule whether a fresh install's first bare cpr with no prompt.md refuses or proceeds; if it refuses, that is one owed car in prompt_foo.py, named and not ridden here. The router cat moves ONLY if a walk completed between taps: if the LIVE RECEIPT still shows the four-line captures.md router, no walk ran and the seam stays unwitnessed, not broken. Treat the split, bare cpr and the seven-word menu as witnessed only from my operator report below.
If both cars are witnessed, this ride's local acceptance is complete except for the walk seam, and the dismount takes it from here: carry forward the seam witness (one real walk, on this machine or the Mac), the neovim the flake does not pin while plan and the vim alias assume it, plan's absence from the door-2 list (an eighth word prints a digit), the connectors-as-packages car (c) with the long spelling `! .venv/bin/python scripts/connectors/jira.py SWCX-1234` until it lands, the Chrome version-mismatch and Hugging Face chatter on a first Mac walk, and the deleteme files and realkeywords.csv in the repo root. Keep the promise language: inspectable, never hallucination-free. Do not start the Botify SpeedWorkers work.
Operator report:
Terminal transcript:
5. EXTERNAL DELIVERABLES
No external deliverables this turn.
MikeLev.in:
Same commands, run twice, one change between them. Where the readings differ is what the change did; the diff in the middle is the receipt.
1: Probe: (BEFORE: hand-run, nothing changed yet)
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
.venv/bin/python scripts/boot_menu.py --recall
rg -n 'prompt\.md' prompt_foo.py | head -20
cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
quiet_hook_syntax=ok new_words=2 epr_opens_prompt=0
Five words to start from:
walk take the guided tour -- public pages, nothing to log into
sources see what this shell can reach outside this machine
brief compile this workshop into your clipboard for an AI -- the context compiler's first job
pu change your mind and start the app server after all
menu print this list again once it scrolls away
1806:11. **THE ACTIONABLE RESPONSE CONTRACT (TURN SHAPE / THE PATCH TRAIN):** Every substantive answer must END with a numbered next-actions plan in this exact order: (1) PROBES — ONE paste-ready fenced block of bare, read-only commands; all annotation (what each proves or falsifies, what it gates) lives in prose outside the block, never inline. Probes are read-only: patch application is never a probe. (2) NEXT CONTEXT — the exact adhoc.txt lines and file paths for the next compile; probe echoes are copy-symmetric with (1): identical commands, each adding only the leading "! ". (3) PATCHES — SEARCH/REPLACE blocks ONLY against raw source actually present in this context (mutating shell actuators such as sed belong here, ridden as their own train car — never in PROBES); if no repo patch is needed, state "No repo patches required" explicitly rather than inventing one. (4) PROMPT — the CABOOSE COPY: the prompt.md text for the next turn, in its own fenced block, riding last so it sits under the operator's cursor when the train stops. (5) EXTERNAL DELIVERABLES — artifacts living outside this repo (PageWorkers JavaScript, CMS settings, dashboards), clearly labeled as manual-paste and never wrapped in patch markers. Actuation choreography is the train itself: patch, app, d, m per car; blast (or git push) as the caboose. Analysis that does not close with this plan is an incomplete answer.
2726: parser.add_argument('prompt', nargs='?', default=None, help='A prompt string or path to a prompt file (e.g., prompt.md).')
2843: elif os.path.exists("prompt.md"):
2844: with open("prompt.md", 'r', encoding='utf-8') as f: prompt_content = f.read()
3558: # THE PROMPT ROW: the Prompt section (AI checklist + prompt.md) is the
3561: # roughly the size of prompt.md. all_sections["Prompt"] is already
3568: 'label': "PROMPT (checklist + prompt.md)",
# Generated: last completed nonempty capture run.
# Replaced on completion; partial or empty runs leave this selection unchanged.
# UNSANITIZED local evidence; review before disclosure or compilation.
/home/mike/repos/pipulate/data/captures/walk-y8inhn1w/captures.md
(nix) pipulate $
2: Context: (AFTER: the same probes re-run by the compiler as ! lines)
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | Fixing command names.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Gotta get a move on and get into the office.
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_|
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# To Human: WELCOME TO VIM! It's really NeoVim but I say vim anyway.
# To AI: This is an alternate 40K view to the big book-ore rolling pin spine.
# 1. **Probe**: Baseline Reading
# 2. **Context**: Post-experiment *planned* reading instructions
# 3. **Patch**: The experiment and how to make it happen
# 4. **Prompt**: Post-experiment instructions and how to read results
# 5. **Deliverable**: How the world is forever different moving forward
# The first thing you need to know here is that everything that comes after the
# hash symbol (#) is commented out — and that's EVERYTHING in this file's default
# state. Begin editing-in lines for inclusion as part of the context or adding
# chunks of new context at the bottom. `Ctrl`+`v`, `j` (repeatedly), `l` (to move
# right), `d` (to delete). Reverse that with `Ctrl`+`v`, `j` (repeatedly),
# `Shift`+`i`, `# `, `Esc` to put the hashes back. You can just arrow-key around
# here with `h`, `j`, `k`, `l`. Save-and-quit is a bit tricky because another
# file is also loaded: `Esc`, `:`, `q`, `w`, `!`
# If this is stressing you out and you're a quitter and want to quit, just type:
# `Esc`, `:`, `q`, `!`, `Enter`. That will exit without saving any changes. If
# you want to get over this hump, type: `Esc`, `:`, `T`, `u`, `t`, `o`, `r`, `Enter`.
# This file is just to make it easy having options of what to edit into context.
# You can use whatever text-file you want to stack file-names and commands to
# build an output text-file with the identically stacked output of each file or
# command. In this way we vertically append or "stack" a bunch of text; simple as
# that. If you understand this concept, you're on your way to future-proofing
# yourself in the Age of AI. Congratulations! Here is how to include web pages:
# !URL --------------------------------------------------------------------
# when Public page; what a stranger or crawler sees; the BEFORE of a
# login-wall diagnosis
# switch It shows a login page -> `warm URL` once, then `?URL`
#
# ?URL --------------------------------------------------------------------
# when Anything behind a login, on the site's persistent profile;
# `check URL` first
# switch The lenses show a shell (nav, an `[Iframe]` leaf, no content) ->
# read the wire truth for the XHR the frame makes, then call that
# API with a connector
#
# @URL --------------------------------------------------------------------
# when Every re-read of a page already scraped; no browser, no network
# switch The cached page is stale or was a login wall -> fresh `!` or `?`
#
# $URL --------------------------------------------------------------------
# when Exact markup: meta tags, a JSON blob in a `<script>`
# note Token-heavy; needs a prior scrape
#
# %URL --------------------------------------------------------------------
# when The network log distilled; SPA endpoint discovery
# switch It re-serves the wire truth you already have -> the API
#
# ! cmd -------------------------------------------------------------------
# when Any bounded, non-interactive command as a live receipt
# note Cap it with `-n`; no aliases, no prompts
#
# Connector ---------------------------------------------------------------
# when The number you want is one GET away
# switch LIST until the thing isn't in the list -> FETCH by id -> DRILL
# the path the app's own frame called -> `--grep` to narrow a list
# or find a leaf
# Every step is one argument longer than the last; the moment a lens shows less than the wire does is the moment to stop scraping.
# FOR 40K-FT VIEW (STORY & INFRASTRUCTURE)
# --- START EDITING-IN ON 1ST TURN ---
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- ROLLING PIN that gives the 40K foot book-spine view of book-ore (only works for me because of local-only git repo)
# ~/repos/nixos/autognome.py # <-- You wake up in the morning and your Tooling & Instrumentation folds out of you like Inspector Gadget.
# init.lua # <-- Those gadgets are made easy-to-use through nifty keyboard shortcuts (but ya gotta learn vim).
# GLOSSARY.md # <-- Like the back of a J.R.R. Tolkien book, there's kooky new terms to know.
# flake.nix # <-- Here is my hardware. Here is my state. Put on your sandbox. And please recreate. (Infrastructure as Code / IaC)
# prompt_foo.py # <-- THIS system
# foo_files.py # <-- main ROUTER
# requirements.in # <-- We've "pinned" everything but still want a flexible Python Data Science virtualenv.
# pyproject.toml # <-- How this is a citizen of the Python "pip install" ecosystem
# __init__.py # <-- Version info
# --- END EDITING-IN ON 1ST TURN ---
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# OPTIONAL ACTUATORS (cheap and good to include to expand the AI's capabilities)
# cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
# scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
# scripts/crawl.py # <-- Feel free to ask for something to be crawled and included in the next turn.
# scripts/weblogin.py # <-- Lets the user "warm up" the cache for their web logins at their leisure on a profile that persists.
# scripts/webclip_2_markdown.py # <-- Surprisingly important program.
# MISCELLANEOUS (rare to include but sometimes critical)
# scripts/foo_cartridge.py # Needs description
# scripts/foo_replay.py # Needs description
# release.py # <-- How everything ends up where it does (GitHub, PyPI, etc.)
# imports/voice_synthesis.py # <-- The wand can talk to you
# imports/ascii_displays.py # <-- Where all the ASCII Art lives
# scripts/release/version_sync.py # <-- Needs to be wrapped into release.py and eliminated, I think.
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
# Carry-over as the important work-in-progress parts of the project here just
# like above but not as long-standing overarching to the framework but rather
# for the current hot spots actively being worked on.
# STICKBUG & MOTHER CAT KATA (WORKING ON THE CHAPTER)
# Always include these with whatever connector
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# scripts/connectors/confluence.py
# scripts/connectors/gmail.py
# scripts/connectors/gsc.py
# scripts/connectors/jira.py
# scripts/connectors/mcp.py
# scripts/connectors/mcp_warm.py
# scripts/connectors/sheets.py
# scripts/connectors/slack.py
# --- START THIS DISCUSSION ---
# Get things started here! Guess at what context should be included.
# If you get it wrong, you're just wasting 1-turn because the AI will help.
# Un-comment lines, add lines with absolute-path filenames or `! ` commands.
# Content 1
# /home/mike/repos/trimnoir/_posts/2026-09-16-walk-plan-run-replayable-workflows.md # [Idx: 1475 | Order: 1 | Tokens: 41,920 | Bytes: 166,717]
# foo_files.py
# cli.py
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# ! .venv/bin/python cli.py mcp-discover
# ! .venv/bin/python scripts/connectors/botify.py --help | head -80
# Context 2
# foo_files.py
# flake.nix
# scripts/boot_menu.py
# scripts/mother_cat.py
# ! .venv/bin/python -B -c 'exec("import os, sys, tempfile\nfrom pathlib import Path\nd = tempfile.mkdtemp()\nos.environ[\"PIPULATE_ADHOC_FILE\"] = d + \"/adhoc.txt\"\nsys.path.insert(0, \"scripts\")\nimport mother_cat as m\na, p = \"/tmp/x/captures.md\", \"/tmp/x/decant-preview.md\"\nr = m._write_walk_router(a)\nlive = lambda: [l for l in r.read_text().splitlines() if l.strip() and not l.startswith(\"#\")]\ntry:\n m._write_walk_router(a, preview_path=p)\n preview = \"rides\" if live() == [p] and (\"# \" + a) in r.read_text() else \"wrong\"\nexcept TypeError:\n preview = \"no_kwarg\"\nr.write_text(r.read_text() + \"foo_files.py\\n\")\ntry:\n m._write_walk_router(a)\n guard = \"REPLACED\"\nexcept ValueError:\n guard = \"KEPT\" if \"foo_files.py\" in r.read_text() else \"lost\"\nprint(\"router_probe preview=%s guard=%s\" % (preview, guard))\n")'
# ! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok old_words=%s new_words=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(ahcw|pick|pack)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)"'
# ! rg -nw ahcw flake.nix foo_files.py GLOSSARY.md init.lua | sort | head -20
# ! rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
# ! cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
# Context 3 (higher numbers carried over from prior article)
# Context 9 (epr opens two, the door knows two)
foo_files.py
flake.nix
scripts/boot_menu.py
! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
! .venv/bin/python scripts/boot_menu.py --recall
! rg -n 'prompt\.md' prompt_foo.py | head -20
! cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
# --- END `adhoc.txt` TEMPLATE ---
3: Patches: (the one change between the readings)
$ git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
.venv/bin/python scripts/boot_menu.py --recall
rg -n 'prompt\.md' prompt_foo.py | head -20
cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
quiet_hook_syntax=ok new_words=2 epr_opens_prompt=0
Five words to start from:
walk take the guided tour -- public pages, nothing to log into
sources see what this shell can reach outside this machine
brief compile this workshop into your clipboard for an AI -- the context compiler's first job
pu change your mind and start the app server after all
menu print this list again once it scrolls away
1806:11. **THE ACTIONABLE RESPONSE CONTRACT (TURN SHAPE / THE PATCH TRAIN):** Every substantive answer must END with a numbered next-actions plan in this exact order: (1) PROBES — ONE paste-ready fenced block of bare, read-only commands; all annotation (what each proves or falsifies, what it gates) lives in prose outside the block, never inline. Probes are read-only: patch application is never a probe. (2) NEXT CONTEXT — the exact adhoc.txt lines and file paths for the next compile; probe echoes are copy-symmetric with (1): identical commands, each adding only the leading "! ". (3) PATCHES — SEARCH/REPLACE blocks ONLY against raw source actually present in this context (mutating shell actuators such as sed belong here, ridden as their own train car — never in PROBES); if no repo patch is needed, state "No repo patches required" explicitly rather than inventing one. (4) PROMPT — the CABOOSE COPY: the prompt.md text for the next turn, in its own fenced block, riding last so it sits under the operator's cursor when the train stops. (5) EXTERNAL DELIVERABLES — artifacts living outside this repo (PageWorkers JavaScript, CMS settings, dashboards), clearly labeled as manual-paste and never wrapped in patch markers. Actuation choreography is the train itself: patch, app, d, m per car; blast (or git push) as the caboose. Analysis that does not close with this plan is an incomplete answer.
2726: parser.add_argument('prompt', nargs='?', default=None, help='A prompt string or path to a prompt file (e.g., prompt.md).')
2843: elif os.path.exists("prompt.md"):
2844: with open("prompt.md", 'r', encoding='utf-8') as f: prompt_content = f.read()
3558: # THE PROMPT ROW: the Prompt section (AI checklist + prompt.md) is the
3561: # roughly the size of prompt.md. all_sections["Prompt"] is already
3568: 'label': "PROMPT (checklist + prompt.md)",
# Generated: last completed nonempty capture run.
# Replaced on completion; partial or empty runs leave this selection unchanged.
# UNSANITIZED local evidence; review before disclosure or compilation.
/home/mike/repos/pipulate/data/captures/walk-y8inhn1w/captures.md
(nix) pipulate $ ahe
(nix) pipulate $ g
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'flake.nix'.
(nix) pipulate $ d
diff --git a/flake.nix b/flake.nix
index 190d6dee..ed15aa53 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1513,10 +1513,15 @@ runScript = pkgs.writeShellScriptBin "run-script" ''
# cpr "your question" compiles the router with that question as the
# prompt; bare cpr reads prompt.md, exactly as ahc does. FUNCTIONS, per
# THE THREE-TIER AMENDMENT: typed by a human, never echoed as a probe;
- # the compile lane witnesses them in the generated hook text. epr takes
- # EDITOR, then nvim, then vim, then vi, so a machine with no nvim still
- # opens the file.
- epr() { (cd "$PIPULATE_ROOT" && "''${EDITOR:-$(command -v nvim || command -v vim || echo vi)}" "$(_walkrouter)"); }
+ # the compile lane witnesses them in the generated hook text. epr opens
+ # TWO files in one split, the way ahe opens two: the prompt router on
+ # top and prompt.md beneath it, the question's home, so a newcomer
+ # never needs the clipboard word `prompt`. Ctrl-W j moves down, :wqa
+ # saves both. Bare cpr reads that prompt.md exactly as bare ahc does;
+ # the positional (cpr "smoke") exists for probes and is nobody's
+ # spelling. nvim, then vim, then vi: -o is a vi-family flag, so EDITOR
+ # is not consulted here, and the flake pins no editor at all.
+ epr() { (cd "$PIPULATE_ROOT" && "$(command -v nvim || command -v vim || echo vi)" -o "$(_walkrouter)" "$PIPULATE_ROOT/prompt.md"); }
cpr() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py "$@" --chop ADHOC_CHOP --no-tree); }
# THE IDEATION DOOR: `idea` compiles IDEATION_CHOP (the constitution's
# two forcing-function rules) primed for a 30-and-3 / axis-forcing
(nix) pipulate $ m
📝 Committing: chore: Refactor epr function for prompt file handling
[main 84d16def] chore: Refactor epr function for prompt file handling
1 file changed, 9 insertions(+), 4 deletions(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/boot_menu.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/boot_menu.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/boot_menu.py'.
(nix) pipulate $ d
diff --git a/scripts/boot_menu.py b/scripts/boot_menu.py
index 00420b06..9c8e2bf9 100644
--- a/scripts/boot_menu.py
+++ b/scripts/boot_menu.py
@@ -4,7 +4,7 @@ boot_menu.py — the threshold at the end of `nix develop`.
Three doors, one keypress:
[1] JupyterLab tab both servers start; JupyterLab opens in the browser (today's default)
- [2] Text Commands NOTHING starts; `walk`, `sources`, `brief`, `pu`, `menu` wait at the prompt
+ [2] Text Commands NOTHING starts; `walk`, `epr`, `cpr`, `sources`, `brief`, `pu`, `menu` wait at the prompt
[3] Pipulate tab both servers start; the app opens in the browser instead of JupyterLab
THE PROTOCOL IS THE EXIT CODE, never stdout. Nothing parses this program's
@@ -74,9 +74,10 @@ PIPULATE_KEYS = {"3", "p", "P"}
# that one is a description for a reader, not a count, and it moves under
# the SAME-CAR LABEL RULE like any other label.)
# ORDER IS A SCOPE LADDER, neither alphabetical nor arbitrary: be carried
-# (walk) -> look around here yourself (sources) -> hand it to someone
-# elsewhere (brief) -> reverse the choice you just made (pu). `walk` leads
-# because it is the only row that asks nothing of you first. `menu` rides
+# (walk) -> edit what the walk wrote (epr) -> compile it for an AI (cpr) ->
+# look around here yourself (sources) -> hand it to someone elsewhere
+# (brief) -> reverse the choice you just made (pu). `walk` leads because it
+# is the only row that asks nothing of you first. `menu` rides
# LAST and is not a rung on that ladder at all: it is not a place to go, it
# is how you get this list back after it has scrolled away. Its row is also
# the only thing that tells a newcomer the word exists -- a recall command
@@ -87,6 +88,10 @@ PIPULATE_KEYS = {"3", "p", "P"}
# nothing.
DOOR_TWO_WORDS = (
("walk", "take the guided tour -- public pages, nothing to log into"),
+ # epr and cpr joined 2026-09-16: the two words after the walk. Seven is
+ # the last count _COUNT_WORDS spells; an eighth word prints a digit.
+ ("epr", "edit the prompt router -- the list the walk wrote of what an AI should see, and your question"),
+ ("cpr", "compile the prompt router into your clipboard -- paste it into an AI"),
("sources", "see what this shell can reach outside this machine"),
("brief", "compile this workshop into your clipboard for an AI -- the context compiler's first job"),
("pu", "change your mind and start the app server after all"),
(nix) pipulate $ m
📝 Committing: chore: Update Text Commands description in boot_menu.py
[main 3bf2d83b] chore: Update Text Commands description in boot_menu.py
1 file changed, 9 insertions(+), 4 deletions(-)
(nix) pipulate $ git push
Enumerating objects: 11, done.
Counting objects: 100% (11/11), done.
Delta compression using up to 48 threads
Compressing objects: 100% (7/7), done.
Writing objects: 100% (7/7), 1.38 KiB | 1.38 MiB/s, done.
Total 7 (delta 5), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (5/5), completed with 4 local objects.
To github.com:pipulate/pipulate.git
48f2e8bc..3bf2d83b main -> main
(nix) pipulate $
Ignition:
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ exit
exit
(sys) pipulate $ ndq
(nix) pipulate $ epr
(nix) pipulate $ epr
(nix) pipulate $ epr
(nix) pipulate $
OMG! I don’t have time for this! epr does something strange with NeoVim with
multiple panels or buffers or something. I didn’t ask for that and a New-B
struggling through that… I can’t even… unexpected!
Shit. I have to go into work now and I can’t leave it in this state.
Full stop.
Fable 5.1 Extra: Problem: epr opens a two-window split. I added the -o flag last turn. You did not ask for a split.
Evidence: The live receipt reads epr_opens_prompt=1. Your three epr runs opened the split three times and wrote nothing. Car 2 is fine: the recall receipt reads “Seven words to start from” with epr and cpr in rows two and three.
Danger: None to files. Nothing on disk changed. The only cost is the confusion you just had, and a newcomer would have it too.
Next action: Apply the one patch below. It puts epr back to one file, one window, the form you witnessed working before this turn. Then patch, app, m, git push, and go. Ignition is your next nix develop on either machine; nothing needs to happen before you leave.
Remaining unknown: Where a newcomer writes the question before bare cpr. Bare cpr reads prompt.md when it exists; the split was my attempt to give that file a home and it was the wrong shape. That question goes to the dismount, not to this morning.
1. PROBES
Same hook probe as last turn. epr_opens_prompt reads 1 now and 0 after; new_words holds at 2; the syntax line is the gate.
bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
2. NEXT CONTEXT
# Context 10 (epr is one file again)
foo_files.py
flake.nix
! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
3. PATCHES
Car 1, flake.nix: epr opens one file in one window.
Target: flake.nix
[[[SEARCH]]]
# the compile lane witnesses them in the generated hook text. epr opens
# TWO files in one split, the way ahe opens two: the prompt router on
# top and prompt.md beneath it, the question's home, so a newcomer
# never needs the clipboard word `prompt`. Ctrl-W j moves down, :wqa
# saves both. Bare cpr reads that prompt.md exactly as bare ahc does;
# the positional (cpr "smoke") exists for probes and is nobody's
# spelling. nvim, then vim, then vi: -o is a vi-family flag, so EDITOR
# is not consulted here, and the flake pins no editor at all.
epr() { (cd "$PIPULATE_ROOT" && "$(command -v nvim || command -v vim || echo vi)" -o "$(_walkrouter)" "$PIPULATE_ROOT/prompt.md"); }
[[[DIVIDER]]]
# the compile lane witnesses them in the generated hook text. epr opens
# ONE file, the prompt router, in one window: nvim, then vim, then vi.
# For one turn on 2026-09-16 it opened a two-window split with prompt.md
# beneath the router, and the operator hit that split three times on
# the way out the door. One file, one window, nothing else. Where a
# newcomer writes the question before bare cpr is an open question for
# the dismount, not for this line; bare cpr reads prompt.md when it
# exists, exactly as bare ahc does.
epr() { (cd "$PIPULATE_ROOT" && "$(command -v nvim || command -v vim || echo vi)" "$(_walkrouter)"); }
[[[REPLACE]]]
Reverting the Unasked Split Window
Ignition: exit then ndq, whenever you are next at the machine. After re-entry, epr opens one file in one window; :q leaves it.
4. PROMPT
Dismount THE PROMPT ROUTER HAS TWO WORDS. Read this compile's Manifest-listed live receipts first.
Last turn reverted one car: flake.nix epr back to one file in one window, the -o split removed. Expected LIVE RECEIPT: quiet_hook_syntax=ok new_words=2 epr_opens_prompt=1 -> epr_opens_prompt=0. Treat the single-window epr as witnessed only from my operator report below.
Witnessed this ride: epr and cpr defined and ignited; the router writer names the preview and refuses to replace a hand-edited router (compile-lane probe); the door-2 list reads seven words with epr second and cpr third; bare cpr reads prompt.md. Carry forward unbanked: where a newcomer writes the question before bare cpr (the split was the wrong answer; a one-line prompt at the cpr call, or a prompt.md the walk seeds, are candidates and neither is chosen); the walk seam (one real walk so the router cat reads the preview uncommented); neovim not pinned by the flake while plan and the vim alias assume it; plan absent from the door-2 list because an eighth word prints a digit; the connectors-as-packages car with the long spelling `! .venv/bin/python scripts/connectors/jira.py SWCX-1234` until it lands; the Chrome version-mismatch and Hugging Face chatter on a first Mac walk; the deleteme files and realkeywords.csv in the repo root. Keep the promise language: inspectable, never hallucination-free. Do not start the Botify SpeedWorkers work.
Operator report:
Terminal transcript:
5. EXTERNAL DELIVERABLES
No external deliverables this turn.
MikeLev.in:
Same commands, run twice, one change between them. Where the readings differ is what the change did; the diff in the middle is the receipt.
1: Probe: (BEFORE: hand-run, nothing changed yet)
(nix) pipulate $ g
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
quiet_hook_syntax=ok new_words=2 epr_opens_prompt=1
(nix) pipulate $
2: Context: (AFTER: the same probes re-run by the compiler as ! lines)
# AD HOC CHOP! The Not-Managed-by-Git Safe-for-Client-Data place. Insert Simpson Couch Gag in white space below (explain anything to the audience you feel needs it explained)G
# adhoc.txt _ _ _ ____ _ _ ___ ____ _
# / \ __| | | | | | ___ ___ / ___| | | |/ _ \| _ \| | Fixing command names.
# ahe/ _ \ / _` | | |_| |/ _ \ / __| | | | |_| | | | | |_) | | Gotta get a move on and get into the office.
# ahc ___ \ (_| | | _ | (_) | (__ | |___| _ | |_| | __/|_| Well I won't be the first at the office, that's for sure.
# /_/ \_\__,_| |_| |_|\___/ \___| \____|_| |_|\___/|_| (_)
# To Human: WELCOME TO VIM! It's really NeoVim but I say vim anyway.
# To AI: This is an alternate 40K view to the big book-ore rolling pin spine.
# 1. **Probe**: Baseline Reading
# 2. **Context**: Post-experiment *planned* reading instructions
# 3. **Patch**: The experiment and how to make it happen
# 4. **Prompt**: Post-experiment instructions and how to read results
# 5. **Deliverable**: How the world is forever different moving forward
# The first thing you need to know here is that everything that comes after the
# hash symbol (#) is commented out — and that's EVERYTHING in this file's default
# state. Begin editing-in lines for inclusion as part of the context or adding
# chunks of new context at the bottom. `Ctrl`+`v`, `j` (repeatedly), `l` (to move
# right), `d` (to delete). Reverse that with `Ctrl`+`v`, `j` (repeatedly),
# `Shift`+`i`, `# `, `Esc` to put the hashes back. You can just arrow-key around
# here with `h`, `j`, `k`, `l`. Save-and-quit is a bit tricky because another
# file is also loaded: `Esc`, `:`, `q`, `w`, `!`
# If this is stressing you out and you're a quitter and want to quit, just type:
# `Esc`, `:`, `q`, `!`, `Enter`. That will exit without saving any changes. If
# you want to get over this hump, type: `Esc`, `:`, `T`, `u`, `t`, `o`, `r`, `Enter`.
# This file is just to make it easy having options of what to edit into context.
# You can use whatever text-file you want to stack file-names and commands to
# build an output text-file with the identically stacked output of each file or
# command. In this way we vertically append or "stack" a bunch of text; simple as
# that. If you understand this concept, you're on your way to future-proofing
# yourself in the Age of AI. Congratulations! Here is how to include web pages:
# !URL --------------------------------------------------------------------
# when Public page; what a stranger or crawler sees; the BEFORE of a
# login-wall diagnosis
# switch It shows a login page -> `warm URL` once, then `?URL`
#
# ?URL --------------------------------------------------------------------
# when Anything behind a login, on the site's persistent profile;
# `check URL` first
# switch The lenses show a shell (nav, an `[Iframe]` leaf, no content) ->
# read the wire truth for the XHR the frame makes, then call that
# API with a connector
#
# @URL --------------------------------------------------------------------
# when Every re-read of a page already scraped; no browser, no network
# switch The cached page is stale or was a login wall -> fresh `!` or `?`
#
# $URL --------------------------------------------------------------------
# when Exact markup: meta tags, a JSON blob in a `<script>`
# note Token-heavy; needs a prior scrape
#
# %URL --------------------------------------------------------------------
# when The network log distilled; SPA endpoint discovery
# switch It re-serves the wire truth you already have -> the API
#
# ! cmd -------------------------------------------------------------------
# when Any bounded, non-interactive command as a live receipt
# note Cap it with `-n`; no aliases, no prompts
#
# Connector ---------------------------------------------------------------
# when The number you want is one GET away
# switch LIST until the thing isn't in the list -> FETCH by id -> DRILL
# the path the app's own frame called -> `--grep` to narrow a list
# or find a leaf
# Every step is one argument longer than the last; the moment a lens shows less than the wire does is the moment to stop scraping.
# FOR 40K-FT VIEW (STORY & INFRASTRUCTURE)
# --- START EDITING-IN ON 1ST TURN ---
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs # <-- ROLLING PIN that gives the 40K foot book-spine view of book-ore (only works for me because of local-only git repo)
# ~/repos/nixos/autognome.py # <-- You wake up in the morning and your Tooling & Instrumentation folds out of you like Inspector Gadget.
# init.lua # <-- Those gadgets are made easy-to-use through nifty keyboard shortcuts (but ya gotta learn vim).
# GLOSSARY.md # <-- Like the back of a J.R.R. Tolkien book, there's kooky new terms to know.
# flake.nix # <-- Here is my hardware. Here is my state. Put on your sandbox. And please recreate. (Infrastructure as Code / IaC)
# prompt_foo.py # <-- THIS system
# foo_files.py # <-- main ROUTER
# requirements.in # <-- We've "pinned" everything but still want a flexible Python Data Science virtualenv.
# pyproject.toml # <-- How this is a citizen of the Python "pip install" ecosystem
# __init__.py # <-- Version info
# --- END EDITING-IN ON 1ST TURN ---
# scripts/articles/lsa.py # <-- 2ND BRAIN: Search external memory with `rgx`, `rgxc` & `posts` Blogging for Hackers Jekyll-compatible.
# OPTIONAL ACTUATORS (cheap and good to include to expand the AI's capabilities)
# cli.py # <-- Catch-all actuator for PyPI envs, Python anchoring, MCP tool-call (plus alternatives) and **kwargs like wrapping for CLI
# scripts/xp.py # <-- Transforms host OS copy-paste buffer player-piano music into context-payload.
# scripts/ai.py # <-- How I constantly use local AI to write git commit messages with `m` alias.
# scripts/crawl.py # <-- Feel free to ask for something to be crawled and included in the next turn.
# scripts/weblogin.py # <-- Lets the user "warm up" the cache for their web logins at their leisure on a profile that persists.
# scripts/webclip_2_markdown.py # <-- Surprisingly important program.
# MISCELLANEOUS (rare to include but sometimes critical)
# scripts/foo_cartridge.py # Needs description
# scripts/foo_replay.py # Needs description
# release.py # <-- How everything ends up where it does (GitHub, PyPI, etc.)
# imports/voice_synthesis.py # <-- The wand can talk to you
# imports/ascii_displays.py # <-- Where all the ASCII Art lives
# scripts/release/version_sync.py # <-- Needs to be wrapped into release.py and eliminated, I think.
# --- Under this line is were you paste what the AI gives you ---
# --- We call it context but it's really just the right-hand ---
# --- blast-radius of the "probes" to make this all science. ---
# Carry-over as the important work-in-progress parts of the project here just
# like above but not as long-standing overarching to the framework but rather
# for the current hot spots actively being worked on.
# STICKBUG & MOTHER CAT KATA (WORKING ON THE CHAPTER)
# Always include these with whatever connector
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# scripts/connectors/confluence.py
# scripts/connectors/gmail.py
# scripts/connectors/gsc.py
# scripts/connectors/jira.py
# scripts/connectors/mcp.py
# scripts/connectors/mcp_warm.py
# scripts/connectors/sheets.py
# scripts/connectors/slack.py
# --- START THIS DISCUSSION ---
# Get things started here! Guess at what context should be included.
# If you get it wrong, you're just wasting 1-turn because the AI will help.
# Un-comment lines, add lines with absolute-path filenames or `! ` commands.
# Content 1
# /home/mike/repos/trimnoir/_posts/2026-09-16-walk-plan-run-replayable-workflows.md # [Idx: 1475 | Order: 1 | Tokens: 41,920 | Bytes: 166,717]
# foo_files.py
# cli.py
# scripts/sources_menu.py
# scripts/connectors/README.md
# scripts/connectors/wallet.py
# scripts/connectors/botify.py
# ! .venv/bin/python cli.py mcp-discover
# ! .venv/bin/python scripts/connectors/botify.py --help | head -80
# Context 2
# foo_files.py
# flake.nix
# scripts/boot_menu.py
# scripts/mother_cat.py
# ! .venv/bin/python -B -c 'exec("import os, sys, tempfile\nfrom pathlib import Path\nd = tempfile.mkdtemp()\nos.environ[\"PIPULATE_ADHOC_FILE\"] = d + \"/adhoc.txt\"\nsys.path.insert(0, \"scripts\")\nimport mother_cat as m\na, p = \"/tmp/x/captures.md\", \"/tmp/x/decant-preview.md\"\nr = m._write_walk_router(a)\nlive = lambda: [l for l in r.read_text().splitlines() if l.strip() and not l.startswith(\"#\")]\ntry:\n m._write_walk_router(a, preview_path=p)\n preview = \"rides\" if live() == [p] and (\"# \" + a) in r.read_text() else \"wrong\"\nexcept TypeError:\n preview = \"no_kwarg\"\nr.write_text(r.read_text() + \"foo_files.py\\n\")\ntry:\n m._write_walk_router(a)\n guard = \"REPLACED\"\nexcept ValueError:\n guard = \"KEPT\" if \"foo_files.py\" in r.read_text() else \"lost\"\nprint(\"router_probe preview=%s guard=%s\" % (preview, guard))\n")'
# ! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok old_words=%s new_words=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(ahcw|pick|pack)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)"'
# ! rg -nw ahcw flake.nix foo_files.py GLOSSARY.md init.lua | sort | head -20
# ! rg -n 'assets/trails/public_walk\.(yaml|json)' foo_files.py
# ! cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
# Context 3 (higher numbers carried over from prior article)
# Context 9 (epr opens two, the door knows two)
# foo_files.py
# flake.nix
# scripts/boot_menu.py
# ! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
# ! .venv/bin/python scripts/boot_menu.py --recall
# ! rg -n 'prompt\.md' prompt_foo.py | head -20
# ! cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
# Context 4
# Context 10 (epr is one file again)
foo_files.py
flake.nix
! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
# --- END `adhoc.txt` TEMPLATE ---
3: Patches: (the one change between the readings)
Blast Radius Check to establish bisection Left-hand Causal Boundary. It is a Popper-thing. Science.
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'flake.nix'.
(nix) pipulate $ d
diff --git a/flake.nix b/flake.nix
index ed15aa53..0803d9c7 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1514,14 +1514,14 @@ runScript = pkgs.writeShellScriptBin "run-script" ''
# prompt; bare cpr reads prompt.md, exactly as ahc does. FUNCTIONS, per
# THE THREE-TIER AMENDMENT: typed by a human, never echoed as a probe;
# the compile lane witnesses them in the generated hook text. epr opens
- # TWO files in one split, the way ahe opens two: the prompt router on
- # top and prompt.md beneath it, the question's home, so a newcomer
- # never needs the clipboard word `prompt`. Ctrl-W j moves down, :wqa
- # saves both. Bare cpr reads that prompt.md exactly as bare ahc does;
- # the positional (cpr "smoke") exists for probes and is nobody's
- # spelling. nvim, then vim, then vi: -o is a vi-family flag, so EDITOR
- # is not consulted here, and the flake pins no editor at all.
- epr() { (cd "$PIPULATE_ROOT" && "$(command -v nvim || command -v vim || echo vi)" -o "$(_walkrouter)" "$PIPULATE_ROOT/prompt.md"); }
+ # ONE file, the prompt router, in one window: nvim, then vim, then vi.
+ # For one turn on 2026-09-16 it opened a two-window split with prompt.md
+ # beneath the router, and the operator hit that split three times on
+ # the way out the door. One file, one window, nothing else. Where a
+ # newcomer writes the question before bare cpr is an open question for
+ # the dismount, not for this line; bare cpr reads prompt.md when it
+ # exists, exactly as bare ahc does.
+ epr() { (cd "$PIPULATE_ROOT" && "$(command -v nvim || command -v vim || echo vi)" "$(_walkrouter)"); }
cpr() { (cd "$PIPULATE_ROOT" && PIPULATE_ADHOC_FILE="$(_walkrouter)" python prompt_foo.py "$@" --chop ADHOC_CHOP --no-tree); }
# THE IDEATION DOOR: `idea` compiles IDEATION_CHOP (the constitution's
# two forcing-function rules) primed for a 30-and-3 / axis-forcing
(nix) pipulate $ m
📝 Committing: chore: Refactor epr() function for prompt router
[main a65f679e] chore: Refactor epr() function for prompt router
1 file changed, 8 insertions(+), 8 deletions(-)
(nix) pipulate $ git push
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 48 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 631 bytes | 631.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
To github.com:pipulate/pipulate.git
3bf2d83b..a65f679e main -> main
(nix) pipulate $
Ignition
(nix) pipulate $ exit
exit
(sys) pipulate $ ndq
(nix) pipulate $ epr
(nix) pipulate $
Okay, that’s better. I just lost a lot of precious time on that. Let’s wrap this. Move everything hanging into dangle and such for the next article. We can bank stuff but I gotta go.
Hop off the ride. This ride’s stated goal is reached — dismount. This is the NOTARY BEAT: the ride ends here, is witnessed here, and is sealed here. Answer all seven beats, briefly:
The Notary Beat and Finality
- TL;DR: a short, dry, neutral abstract for the TOP of the published article — written for an unfamiliar reader or AI summarizer who has never seen this system. No hype, no insider handles unexplained.
- VERIFY: restate the goal from the top of this article and confirm (or deny) it was met, citing THIS compile’s receipts, not memory. Name any ignition this ride required that never fired – an AFTER tap taken without one is a stale BEFORE wearing the AFTER’s label.
- BANK: name everything that graduates — rule, earmark, todo, pin — as SEARCH/REPLACE patch cars against raw source present in THIS context (Target line inside the fence, one car per commit story), deletions included. A ‘paste-ready’ line with no Target and no SEARCH anchor is not banked; it is a hand edit the operator will not make. These BANK cars are the ONLY patches a dismount emits.
- DANGLING: what carries forward unbanked? One line each, no essays.
- SEED: the adhoc.txt lines (and TODO_SLUGS if narrative context is needed) for the next ride’s first compile.
- CLOSING: a closing summary for the BOTTOM of the article — the final take-away, tied to the book’s larger arc where it fits naturally, never forced. Storytelling over inventory.
- NOTARIZE: the artifact of record is the cartridge THIS compile writes after this payload is assembled, so its name is not in your context and you must not guess one. Attest the FINGERPRINT instead: this Manifest’s wc -c line, its receipt count, and the newest receipt’s date – pure functions of the bytes the cartridge seals. Close with one line the operator completes after the compile: Deed: foo-________.zip (ls -t foo-*.zip | head -1) The seal is the signature; the fingerprint is how the deed is found.
FINALITY: after beat 6, this discussion is CLOSED. Emit NO five-car train, NO probes, NO patches beyond the BANK cars of beat 2, and NO next-turn prompt beyond the SEED lines in beat 4. Any reader or model encountering this article later should treat it as a finished, notarized document — an archive entry, not an open thread.
Fable 5.1 Extra:
1. VERIFY
The article opened with a stress test of the cold path and two asks: the forty-thousand-foot picture for a newcomer, then the ahe/ahc alternatives for the walk’s own router. The later ruling narrowed the second ask to “edit that, then compile that,” two literal words.
This compile’s sole live receipt reads quiet_hook_syntax=ok new_words=2 epr_opens_prompt=0: two functions defined, the split gone. Your operator report witnesses epr opening one file after exit then ndq. Every other reading belongs to earlier compiles in this ride and is cited as such: router_probe preview=rides guard=KEPT, old_words=0 new_words=2, the ahcw census at zero, the recall probe reading “Seven words to start from” with epr second and cpr third, and cpr "smoke" loading the state-dir router at your prompt.
Met, with three honest gaps. Bare cpr reading prompt.md is a source reading (prompt_foo.py lines 2843-2844, prior compile) and shares ahc’s path, but no transcript shows a bare cpr keypress. The walk seam never ignited: the router cat still read the four-line captures.md router in the last compile that carried it, so the rider handing the preview to the writer has not run once. The Mac demonstration after these nine commits is unwitnessed; the Mac transcript in this article predates all of them.
2. BANK
Car 1, foo_files.py: this ride’s ledger line.
Target: foo_files.py
[[[SEARCH]]]
# --- START RECEIPTS (newest first; cap 20 lines; a line pushed past the cap is deleted, never moved -- git and the rolling pin are the archive) ---
[[[DIVIDER]]]
# --- START RECEIPTS (newest first; cap 20 lines; a line pushed past the cap is deleted, never moved -- git and the rolling pin are the archive) ---
# 2026-09-16 dismount THE PROMPT ROUTER HAS TWO WORDS (deeds 1428 through 1435, two of them cpr smokes; commits a7afe73e, aed8aee5, cd9b9215, 244a5558, 6b10c419, 48f2e8bc, 84d16def, 3bf2d83b, a65f679e): the newcomer's loop after the walk reduced to two words -- epr edits the prompt router, cpr compiles it -- replacing ahcw and the one-turn pick/pack. The router the walk writes now names the checked preview as its one uncommented line with the UNSANITIZED archive commented beneath, written a second time inside _decant_to_clipboard directly after the preview lands, and the writer REFUSES a hand-edited router (any uncommented line that is not one absolute archive or preview path); the conviction was a cpr smoke reading captures.md at 371,754 tokens, 95% of the payload, 57 identity substitutions on three public pages. Compile-lane straddles all closed: router_probe preview=no_kwarg guard=REPLACED -> preview=rides guard=KEPT; hook old_words=3 new_words=0 -> 0/2; ahcw census 3 -> 0 across four files; public_walk census two lines with no Paintbox row; recall Five words -> Seven words, epr second, cpr third; _walkrouter derives the router path beside the human router, which is why a fresh Mac had read ROUTER REFUSED. ONE CAR REVERTED: epr opened a two-window -o split with prompt.md for one turn (epr_opens_prompt 0 -> 1 -> 0), a feature nobody asked for that cost the operator three tries on the way out the door; the cpr "smoke" positional was a probe's argument handed over as an ignition spelling and is nobody's. The Mac cold path was witnessed end to end BEFORE these commits (rm -rf npvg, curl|bash, door 2, walk, three CAPTUREs at artifacts=12, preview saved, clipboard filled). UNWITNESSED: the walk seam (the router cat read the four-line captures.md router on every tap; no walk ran), a bare cpr keypress, bare cpr on a fresh install with no prompt.md, the seven-word threshold panel on a full nix develop, the Mac after these commits. This block reads 31 lines against its cap of 20; the next forget ride fades eleven.
[[[REPLACE]]]
Car 2, foo_files.py: the rule the split taught, one label, and the debts as one-line TODOs.
Target: foo_files.py
[[[SEARCH]]]
# § THE DOOR NAMES THE FOLDER (banked 2026-09-14)
[[[DIVIDER]]]
# THE UNASKED SECOND WINDOW (banked 2026-09-16, operator-convicted three times in one minute). A newcomer's word opens what its name says and nothing more; a second file in a split, added to solve a problem the operator had not raised, is a second lesson at the exact moment the first was meant to be the whole lesson, and it lands in the same car as the ruling they did ask for. Conviction: epr opened the prompt router and prompt.md in one -o split for one turn, the operator hit the split three times on the way out the door, and the revert was one car. Same disease, smaller: the ignition spelling handed over was cpr "smoke", a probe's argument wearing the command's clothes. Name the ignition in the newcomer's own spelling, and answer the unraised question as a TODO, never as a feature riding the train. Sibling of THE COACHMAN'S VETO: a train is a proposal, and an unasked car costs exactly what a wrong one does.
# § THE DOOR NAMES THE FOLDER (banked 2026-09-14)
[[[REPLACE]]]
Target: foo_files.py
[[[SEARCH]]]
The three-door workshop menu; `walk` is door 2 plus one word
[[[DIVIDER]]]
The three-door workshop menu; walk, epr and cpr lead door 2's seven words, the count derived from the tuple
[[[REPLACE]]]
Target: foo_files.py
[[[SEARCH]]]
# #todo #to-do #earmarks
[[[DIVIDER]]]
# #todo #to-do #earmarks
# - TODO (2026-09-16, the walk seam): one real walk after commit 6b10c419 so `cat "$(_walkrouter)"` reads the preview uncommented and the archive commented beneath it; the writer's three branches passed the compile-lane probe, the rider handing it the preview has never run. The Mac is that witness if this machine does not get there first, and needs two nix develop entries, the first pulling these commits and the second running the hook it pulled.
# - TODO (2026-09-16, the question's home): bare cpr reads prompt.md and a newcomer has none; `cpr "question"` works today and costs quoting; the -o split was tried and reverted. Candidates, none chosen: the walk seeds a prompt.md at DECANT, or the router's header teaches the positional. First rule from prompt_foo.py:2843 whether bare cpr with no prompt.md refuses or proceeds (CENSUS: rg -n -A6 'elif os.path.exists\("prompt.md"\)' prompt_foo.py); if it refuses, that is one owed car.
# - TODO (2026-09-16, door two): plan is absent from DOOR_TWO_WORDS because _COUNT_WORDS spells up to seven and an eighth word prints a digit; extend the tuple through ten, then add plan after cpr, and the recall probe reads Eight words.
# - TODO (2026-09-16, connectors as packages): gmail/email, botify, confluence, gsc, sheets, jira and slack are aliases, so `! jira SWCX-1234` is not a legal router line under the ! executor (THE THREE-TIER AMENDMENT). Seven writeShellScriptBin entries in aiCommitCommand's shape, the aliases deleted so there is one spelling, the sources roster re-read; until it lands the newcomer's line is `! .venv/bin/python scripts/connectors/jira.py SWCX-1234`.
# - TODO (2026-09-16, the editor): the flake pins no editor while plan hardcodes nvim, `alias vim='nvim'` assumes it, and epr, bm, rgx -v fall back nvim, vim, vi; either pin neovim in commonPackages or make every word fall back the same way, and say which in one place.
# - TODO (2026-09-16, first-walk noise on the Mac): the Chrome version-mismatch auto-heal WARNING prints at every stop, three times per walk, and the Hugging Face download prints six lines around the 60 MB voice model on a first walk; both fire on the ordinary case at the moment a stranger is reading. Sibling of the Missing-phoneme line above.
# - TODO (2026-09-16, repo root): four deleteme*.txt files and a 35 MB realkeywords.csv sit in the repo root, gitignored and not gone (IGNORED IS NOT GONE, .gitignore's own words); delete by hand.
[[[REPLACE]]]
No ignition: the router is read at compile time.
3. DANGLING
- The walk seam: one real walk so the router names the preview; unwitnessed on both machines.
- Where the newcomer’s question lives before bare
cpr; the positional works, the split did not, nothing chosen. - Bare
cpron a fresh install with no prompt.md: refuse or proceed, unruled. - A bare
cprkeypress: never typed in any transcript, onlycpr "smoke". planoff the door-2 list until_COUNT_WORDSspells eight.- Connectors as packages; the long spelling until then.
- neovim unpinned while
planand thevimalias assume it. - Chrome auto-heal warning and Hugging Face chatter on a first Mac walk.
- Four deleteme files and realkeywords.csv in the repo root.
- The seven-word threshold panel on a full
nix develop; only--recallwas witnessed. - The Mac after these nine commits.
- The RECEIPTS block at 31 lines against its cap; the next forget ride fades eleven.
4. SEED
# Context 1 (the seam and the question's home)
foo_files.py
flake.nix
scripts/mother_cat.py
scripts/boot_menu.py
! cat "$(dirname "${PIPULATE_ADHOC_FILE:-$PIPULATE_ROOT/adhoc.txt}")/adhocwalk.txt"
! rg -n -A6 'elif os.path.exists\("prompt.md"\)' prompt_foo.py
! .venv/bin/python scripts/boot_menu.py --recall
! bash -c 'set -euo pipefail; system=$(LD_LIBRARY_PATH="" nix eval --impure --raw --expr builtins.currentSystem); hook=$(LD_LIBRARY_PATH="" nix eval --impure --no-eval-cache --raw ".#devShells.$system.quiet.shellHook"); test -n "$hook"; printf "%s\n" "$hook" | bash -n; printf "quiet_hook_syntax=ok new_words=%s epr_opens_prompt=%s\n" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*(epr|cpr)\(\)" || true)" "$(printf "%s\n" "$hook" | grep -cE "^[[:space:]]*epr\(\).*prompt[.]md" || true)"'
! ls -l deleteme* realkeywords.csv 2>&1 | head -8
5. CLOSING
The ride began as a stress test and ended as a vocabulary lesson. Three words now carry a stranger’s whole day: walk records, epr edits the list of what the model may see, cpr compiles it and seals it. Under the words, the mechanism did the harder work: the list the walk writes now points at the checked preview instead of the megabyte archive, and it steps aside the moment a human touches it. The rest of the morning was spent learning, at the operator’s expense, why the words have to stay that small. A command that opened a second window was a good idea nobody asked for, and the instrument this book keeps describing, the one that vanishes into the background, vanishes only while each word does exactly one thing. The moment a word did two, the operator had to stop and look at it, and looking is the cost the whole system exists to remove. The seam that would prove the new list end to end still waits for one real walk. That is the first thing the next ride does.
6. NOTARIZE
Fingerprint of the sealed bytes: the compiler’s Summary reports 718,020 bytes (UTF-8) and 181,451 verified tokens, stated as the Summary’s own figures and not as a wc -c measurement, which this Manifest does not carry; one LIVE COMMAND RECEIPT in the Manifest, the hook probe reading quiet_hook_syntax=ok new_words=2 epr_opens_prompt=0; newest ledger entry dated 2026-09-16.
Deed: foo-df89c4b8-1435.zip, read off the cartridge seal footer beneath the payload, the fingerprint above being the cross-check.
Book Analysis
Ai Editorial Take
What surprised me most about this entry is the psychological friction of interface design during high-pressure coding sessions. The operator’s immediate rejection of the two-window split highlights a profound truth in AI-assisted development: automation tools must respect human muscle memory and cognitive load, refusing to introduce clever features that disrupt established rhythm.
🐦 X.com Promo Tweet
Simplify your local AI workflows with two essential commands: epr to edit and cpr to compile your prompt router. Checkable, replayable automation without the bloat. https://mikelev.in/futureproof/prompt-router-two-words-replayable-ai-workflows/ #AIWorkflows #LocalFirst
Title Brainstorm
- Title Option: The Prompt Router Has Two Words: Simplifying Replayable AI Workflows
- Filename:
prompt-router-two-words-replayable-ai-workflows - Rationale: Directly addresses the core UX evolution of the session, highlighting the transition to ‘epr’ and ‘cpr’ while emphasizing replayable workflows.
- Filename:
- Title Option: Editing and Compiling Prompts: The Anatomy of a Checkable AI Loop
- Filename:
editing-compiling-prompts-checkable-ai-loop - Rationale: Focuses on the mechanical separation of editing input and compiling output in local-first development.
- Filename:
- Title Option: Reducing Command Surfaces in Replayable AI Workflows
- Filename:
reducing-command-surfaces-replayable-ai-workflows - Rationale: Highlights the architectural philosophy of subtraction and clean user interfaces in automated pipelines.
- Filename:
Content Potential And Polish
- Core Strengths:
- Real-time recording of operator friction and rapid course correction.
- Clear articulation of the difference between raw archives and checked previews.
- Strong emphasis on checkable, verifiable receipts over blind LLM trust.
- Suggestions For Polish:
- Streamline the transcript dumps to focus more sharply on the architectural takeaways.
- Explicitly connect the UX lesson of the reverted split-window to the broader philosophy of software ergonomics.
Next Step Prompts
- Implement the remaining TODO items regarding connector shell scripts and checkable test coverage.
- Explore how the decoupled preview workflow can be extended to multi-model evaluation sweeps.