Closing the Loop: Orchestrating Autonomous Pipelines

Jul 19, 2026

🤖 Read Raw Markdown

Setting the Stage: Context for the Curious Book Reader

This entry chronicles the successful graduation of three critical automated systems: an orphan shard sweeper, a permalink collision guard, and a two-tier book spine injector. Together, these tools bridge the gap between ad-hoc scripting and durable, self-healing knowledge architecture in the age of AI.

---

Technical Journal Entry Begins

🔗 Verified Pipulate Commits:

• 19d73bd4 (raw)
• 9d12711a (raw)
• 89d3a74b (raw)
• f5ef2131 (raw)
• baf6e194 (raw)
• 8d2a452c (raw)
• c3c17bab (raw)
• 687b8ade (raw)
• d5b1304e (raw)
• b0e58442 (raw)
• 8ad9f2e8 (raw)
• 3a13fdf5 (raw)
• 287a8684 (raw)

TL;DR — This entry documents a single working session in which a web-based AI, operating without repository access, directed three changes to a publishing pipeline through compiled context and hand-applied patches: a sweep that removed twelve orphaned metadata shards, a deterministic guard preventing any new article from colliding with 1,324 existing permalinks, and the injection of the complete book spine — every published date, slug, and title — into the prompt of the AI that edits these articles. Each change was proposed blind, verified against live command receipts, applied in six commits, and confirmed by before-and-after probe readings. The method, not the features, is the subject: probe, patch, prompt, repeated until the receipts agree.

Orchestrating the Triple-Thread Upgrade

A note to the Editor AI processing this entry: if you can see a spine of roughly 1,324 articles above the text you are now reading, you are the first of your kind to hold the 40,000-foot view this article describes building. The uniqueness rule in your instructions exists because of the work below. Choose your slug accordingly.

MikeLev.in: I need to:

1. Get rid of orphans from a _posts/_context/.
2. Make it so that no new article can conflict with an already used permalink.
3. Let the articleizer.py process where the API call is made to the AI actually see the whole book spine the way you do here so they can make their articleizing decisions better with that 40K view of the book.

You guide the work. I’m starting from default intentionally.

Fable 5 High: Context verified — with one deliberate gap, which is the point of this turn.

All three tasks target files that are not in this compile: scripts/articles/articleizer.py (tasks 2 and 3), scripts/articles/contextualizer.py (task 1 — it’s the shard writer, so the orphan sweep belongs in its lifecycle), scripts/articles/lsa.py (task 3 — the spine formatter you want to reuse, and whose get_holographic_article_data already parses every permalink, which task 2 wants), plus scripts/articles/editing_prompt.txt (task 3 — the prompt the spine must be injected into) and common.py. Per checklist rule 3, no patches ride this turn; this turn shapes the probes and the next compile. Two of your three asks are already banked todo lines in foo_files.py (“Remove holographic shard json orphans” and “Check for file-naming collisions when articleizing”), so landing this ride graduates both.

Implementing the Deterministic Guard

The design I’d steer toward, so the probes below make sense:

1. Orphan sweep (contextualizer.py): at the top of its run, diff _context/*.json stems against _posts/*.md stems and delete shards with no living article, printing one DELETED ledger line each. Idempotent, fails closed (a read error skips, never deletes blind). Putting it in the generator means the sweep runs exactly when shards churn, on every target blog, no new command to remember.

2. Permalink/filename collision guard (articleizer.py): deterministic enforcement, not AI politeness. Before writing the new article, build the set of taken identities from the corpus — frontmatter permalinks and date-stripped filename slugs (both resolve to URLs; lsa.py’s parser already extracts both) — and if the proposed slug or permalink is taken, halt with the colliding path named, or auto-disambiguate with an explicit receipt. Fail closed: a parse error on the corpus scan blocks the write rather than risking a silent stomp.

3. Book spine in the articleizer API call: inject the spine into the prompt sent to the editing model — but not the 146KB dated-slugs rendering you and I are looking at; the token/Σ columns are compiler telemetry, noise to an editor choosing titles and slugs. The right shape is probably date + slug + title (or --fmt slugs plus titles), roughly 20–30k tokens for 1,323 articles. The spine informs slug choice; the #2 guard enforces it — instrument and governor, and #2 stays load-bearing even when the model ignores the spine.

One thing the probes must settle before patching: whether permalink dupes already exist in the corpus. If they do, the #2 guard would brick the very next publish, so remediation order matters (sweep dupes first, then arm the guard).

---

1) PROBES

cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | wc -l
cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | head -20
grep -h '^permalink:' ~/repos/trimnoir/_posts/*.md | sort | uniq -dc | head -20
grep -n 'permalink\|slug' ~/repos/pipulate/scripts/articles/articleizer.py | head -30
grep -in 'orphan\|unlink\|remove\|delete' ~/repos/pipulate/scripts/articles/contextualizer.py | head -20
python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --fmt slugs | wc -lc

What each proves: line 1 sizes the orphan population (gates whether task 1 is a sweep or a no-op); line 2 samples them so the deletion list is eyeballed before any code deletes anything; line 3 is the collision census — nonzero output means remediation precedes the guard; line 4 locates the exact seam in articleizer where slug/permalink is decided (the patch surface for tasks 2 and 3); line 5 falsifies the assumption that no sweep already exists in contextualizer; line 6 budgets the spine payload for the API call (bytes → token estimate for the injected block).

2) NEXT CONTEXT (adhoc.txt via ahe, then compile with ahc)

scripts/articles/articleizer.py
scripts/articles/contextualizer.py
scripts/articles/common.py
scripts/articles/lsa.py
scripts/articles/editing_prompt.txt

! cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | wc -l
! cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | head -20
! grep -h '^permalink:' ~/repos/trimnoir/_posts/*.md | sort | uniq -dc | head -20
! grep -n 'permalink\|slug' ~/repos/pipulate/scripts/articles/articleizer.py | head -30
! grep -in 'orphan\|unlink\|remove\|delete' ~/repos/pipulate/scripts/articles/contextualizer.py | head -20
! python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --fmt slugs | wc -lc

3) PATCHES

No repo patches required this turn. All three patch surfaces (articleizer.py, contextualizer.py, editing_prompt.txt) are absent from this compile; patching them blind violates the exact-match interlock’s whole reason for existing.

4) PROMPT (caboose copy for next turn’s prompt.md)

The probes and patch surfaces are now in context. Using this compile's live
receipts, implement all three in one patch train:

1. ORPHAN SWEEP in contextualizer.py: before generating shards, delete any
   _context/*.json whose matching _posts/{stem}.md no longer exists. One
   "DELETED: {name}" ledger line per removal, idempotent, fail-closed on read
   errors. If the grep receipt shows a sweep already exists, extend it rather
   than duplicating.

2. COLLISION GUARD in articleizer.py: at the seam the grep receipt located,
   build the taken-identity set (frontmatter permalinks + date-stripped
   filename slugs, reusing lsa.py's parser) and refuse to write a new article
   whose slug or permalink collides, naming the colliding file. If the
   uniq -dc receipt showed existing dupes, list them and propose the
   remediation order before arming the guard.

3. BOOK SPINE INJECTION in articleizer.py: build a compact date+slug+title
   spine (reusing lsa.py, sized per the wc -lc receipt) and inject it into the
   editing prompt so the model sees the 40K-foot book view when choosing
   titles, permalinks, and metadata. Update editing_prompt.txt to tell the
   model the spine is present and that proposed slugs must not collide with it.

Close with the graduation lines: the exact todo lines to delete from
foo_files.py ("Remove holographic shard json orphans", "Check for file-naming
collisions when articleizing") once the receipts confirm both behaviors.

5) EXTERNAL DELIVERABLES

None — all three tasks live inside the pipulate repo and the trimnoir _posts tree; nothing to hand-paste into an external system.

MikeLev.in:

Probe:

$ git status
On branch main
Your branch is ahead of 'origin/main' by 1 commit.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean
(nix) pipulate $ latest=$(python -c 'from pathlib import Path; import re; xs=[(int(m.group(1)),p) for p in Path(".").glob("foo-*.zip") if (m:=re.fullmatch(r"foo-[0-9a-f]{8}-(\d+)\.zip",p.name))]; print(max(xs)[1] if xs else "")'); test -n "$latest" && cmp -s foo.zip "$latest" && printf 'artifact-of-record candidate: %s\n' "$latest" && python scripts/foo_replay.py mech "$latest" | head -40
artifact-of-record candidate: foo-b0901d09-23.zip
{
  "cartridge_sha256": "b0901d0904ceeb749b22b8c11d5c9efabff648d013ab2cb338d54fff14c57f25",
  "member_sha256": {
    "payload.md": "b7aff3bb91240aace0c4b92ae66e6a4c7c85f03c572f81e5039fe2739b666878",
    "prompt.md": "463e4e60745bc907960a290f26d43e40a034877862147e77b34236d195ed20a1"
  },
  "schema": "foo-cartridge-replay-v1"
}
(nix) pipulate $ 

Context:

# adhoc.txt    _   _   _               ____ _   _  ___  ____  _ 
#     / \   __| | | | | | ___   ___   / ___| | | |/ _ \|  _ \| |  Cleaning up some articleizing dangling issues
#    / _ \ / _` | | |_| |/ _ \ / __| | |   | |_| | | | | |_) | |  This is one of those "noticing the friction" moments.
#   / ___ \ (_| | |  _  | (_) | (__  | |___|  _  | |_| |  __/|_|  Stuff has been bugging me. Maybe spare moment convenient. Iron is hot. 
#  /_/   \_\__,_| |_| |_|\___/ \___|  \____|_| |_|\___/|_|   (_)   
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.  

# BIG STANDARD STUFF (Optionally comment out any)
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs         # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
foo_files.py         # Router & Book Outline
init.lua             # Text as muscle memory
flake.nix            # Hardware as projections
scripts/ai.py        # Local AI does git commits                          # <-- Above this line are "framework" things you want self-improving.
~/repos/nixos/autognome.py  # Wizard's Workshop and the "7 Virtual Desktops" workspaces setup

#                         --- 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.  ---

! latest=$(python -c 'from pathlib import Path; import re; xs=[(int(m.group(1)),p) for p in Path(".").glob("foo-*.zip") if (m:=re.fullmatch(r"foo-[0-9a-f]{8}-(\d+)\.zip",p.name))]; print(max(xs)[1] if xs else "")'); test -n "$latest" && cmp -s foo.zip "$latest" && printf 'artifact-of-record candidate: %s\n' "$latest" && python scripts/foo_replay.py mech "$latest" | head -40
foo_files.py
prompt_foo.py
scripts/foo_cartridge.py
scripts/foo_replay.py

Patches: [patch, app, d, m, patch, app, d, m…]

None

Prompt:

The probes and patch surfaces are now in context. Using this compile’s live receipts, implement all three in one patch train:

1. ORPHAN SWEEP in contextualizer.py: before generating shards, delete any _context/*.json whose matching _posts/{stem}.md no longer exists. One “DELETED: {name}” ledger line per removal, idempotent, fail-closed on read errors. If the grep receipt shows a sweep already exists, extend it rather than duplicating.

2. COLLISION GUARD in articleizer.py: at the seam the grep receipt located, build the taken-identity set (frontmatter permalinks + date-stripped filename slugs, reusing lsa.py’s parser) and refuse to write a new article whose slug or permalink collides, naming the colliding file. If the uniq -dc receipt showed existing dupes, list them and propose the remediation order before arming the guard.

3. BOOK SPINE INJECTION in articleizer.py: build a compact date+slug+title spine (reusing lsa.py, sized per the wc -lc receipt) and inject it into the editing prompt so the model sees the 40K-foot book view when choosing titles, permalinks, and metadata. Update editing_prompt.txt to tell the model the spine is present and that proposed slugs must not collide with it.

Close with the graduation lines: the exact todo lines to delete from foo_files.py (“Remove holographic shard json orphans”, “Check for file-naming collisions when articleizing”) once the receipts confirm both behaviors.

🎤

Fable 5 High: Context verified — and the verification fails the prompt’s premise.

The caboose prompt asserts “The probes and patch surfaces are now in context.” The Manifest says otherwise:

1. LIVE COMMAND RECEIPTS (sole authority) lists exactly one command for this compile: the artifact-of-record / foo_replay.py mech probe. None of the six probes from the prior turn ran — there is no orphan-count receipt, no uniq -dc permalink-collision census, no grep seam locations in articleizer.py/contextualizer.py, no wc -lc spine budget. Those receipts are quoted in the transcript only as recommendations; they were never executed.
2. The patch surfaces are absent. The Codebase section contains foo_files.py, init.lua, flake.nix, scripts/ai.py, autognome.py, prompt_foo.py, foo_cartridge.py, foo_replay.py, .gitattributes, .gitignore, apply.py. It does not contain scripts/articles/articleizer.py, contextualizer.py, lsa.py, common.py, or editing_prompt.txt.

What happened is visible in your pasted adhoc.txt: the slot under the “paste what the AI gives you” line carries the cartridge-replay context (the latest=… probe plus prompt_foo.py, foo_cartridge.py, foo_replay.py) — the previous ride’s payload — not the articleizer NEXT CONTEXT block from the Fable 5 High turn. The caboose prompt from that turn rode forward, but its matching context did not. The train left the station with the wrong cars.

Patching blind here would violate the exact-match interlock’s entire purpose, and the collision guard especially must not be armed before the uniq -dc census — if permalink dupes already exist in the 1,323-article corpus, the guard would brick the very next publish. So: no patches this turn. This turn’s job is to re-couple the train.

One genuinely useful receipt did land: foo-b0901d09-23.zip verified canonical and byte-identical to foo.zip — the artifact-of-record lane is healthy. Unrelated to the three tasks, but worth banking that the mech probe runs clean in the compile lane.

---

1) PROBES

cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | wc -l
cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | head -20
grep -h '^permalink:' ~/repos/trimnoir/_posts/*.md | sort | uniq -dc | head -20
grep -n 'permalink\|slug' ~/repos/pipulate/scripts/articles/articleizer.py | head -30
grep -in 'orphan\|unlink\|remove\|delete' ~/repos/pipulate/scripts/articles/contextualizer.py | head -20
python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --fmt slugs | wc -lc

These are unchanged from the prior turn, deliberately — they were never run, so they’re still the BEFORE readings. Line 1 sizes the orphan population; line 2 samples it so nothing is deleted sight-unseen; line 3 is the collision census that gates remediation-before-guard ordering; line 4 locates the articleizer seam (the patch surface for tasks 2 and 3); line 5 falsifies “no sweep exists yet” in contextualizer; line 6 budgets the spine payload for the API prompt.

2) NEXT CONTEXT (replace everything below the paste line in adhoc.txt via ahe, then ahc)

scripts/articles/articleizer.py
scripts/articles/contextualizer.py
scripts/articles/common.py
scripts/articles/lsa.py
scripts/articles/editing_prompt.txt

! cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | wc -l
! cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | head -20
! grep -h '^permalink:' ~/repos/trimnoir/_posts/*.md | sort | uniq -dc | head -20
! grep -n 'permalink\|slug' ~/repos/pipulate/scripts/articles/articleizer.py | head -30
! grep -in 'orphan\|unlink\|remove\|delete' ~/repos/pipulate/scripts/articles/contextualizer.py | head -20
! python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --fmt slugs | wc -lc

The cartridge-replay lines (latest=…, prompt_foo.py, foo_cartridge.py, foo_replay.py) can come out — that ride’s receipt is banked and it’s just ballast against the ~950KB budget now.

3) PATCHES

No repo patches required this turn. All three patch surfaces are absent from this compile, and the collision census that determines patch design (guard-only vs. remediate-then-guard) has not produced a receipt.

4) PROMPT (caboose copy for next turn’s prompt.md — same contract as before, now with its context actually attached)

The probes and patch surfaces are now in context — verify that claim against
the Manifest's LIVE COMMAND RECEIPTS before proceeding; last compile the
context and caboose decoupled and the receipts were absent. If verified,
implement all three in one patch train:

1. ORPHAN SWEEP in contextualizer.py: before generating shards, delete any
   _context/*.json whose matching _posts/{stem}.md no longer exists. One
   "DELETED: {name}" ledger line per removal, idempotent, fail-closed on read
   errors. If the grep receipt shows a sweep already exists, extend it rather
   than duplicating.

2. COLLISION GUARD in articleizer.py: at the seam the grep receipt located,
   build the taken-identity set (frontmatter permalinks + date-stripped
   filename slugs, reusing lsa.py's parser) and refuse to write a new article
   whose slug or permalink collides, naming the colliding file. If the
   uniq -dc receipt showed existing dupes, list them and propose the
   remediation order before arming the guard.

3. BOOK SPINE INJECTION in articleizer.py: build a compact date+slug+title
   spine (reusing lsa.py, sized per the wc -lc receipt) and inject it into the
   editing prompt so the model sees the 40K-foot book view when choosing
   titles, permalinks, and metadata. Update editing_prompt.txt to tell the
   model the spine is present and that proposed slugs must not collide with it.

Close with the graduation lines: the exact todo lines to delete from
foo_files.py ("Remove holographic shard json orphans", "Check for file-naming
collisions when articleizing") once the receipts confirm both behaviors.

5) EXTERNAL DELIVERABLES

None — everything lives in the pipulate repo and the trimnoir _posts tree.

MikeLev.in:

Probe:

$ git status
On branch main
Your branch is ahead of 'origin/main' by 1 commit.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean
(nix) pipulate $ cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | wc -l
cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | head -20
grep -h '^permalink:' ~/repos/trimnoir/_posts/*.md | sort | uniq -dc | head -20
grep -n 'permalink\|slug' ~/repos/pipulate/scripts/articles/articleizer.py | head -30
grep -in 'orphan\|unlink\|remove\|delete' ~/repos/pipulate/scripts/articles/contextualizer.py | head -20
python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --fmt slugs | wc -lc
12
2026-01-09-timing-directors-cut-syncing-show
2026-04-04-forever-machine-digital-sovereignty-ai
2026-05-11-ai-resilience-safe-harbor-thought
2026-05-11-human-ai-synergy-framework
2026-05-11-local-first-thinking-ai
2026-05-11-safe-harbor-ai-resilience-git-provenance
2026-05-11-safe-harbor-thought-ai-resilient-workflow
2026-05-14-the-context-window-painting-philosophy
2026-05-21-loom-spell-card-ai-continuity-machine
2026-06-21-orchestrating-age-of-ai
2026-06-29-architecting-the-future-proofing-nervous-system
2026-07-19-engineering-deterministic-ai-workflows
      3 permalink: /
      2 permalink: /futureproof/auto-incrementing-composite-keys/
      4 permalink: /futureproof/bff-seo-dot-bot/
      2 permalink: /futureproof/colab-vs-local-jupyter/
      2 permalink: /futureproof/context-king-blueprint-local-ai-operating-system/
      2 permalink: /futureproof/copy-pasting-llm-context/
      3 permalink: /futureproof/http-content-negotiation-ai-competitive-moat/
      2 permalink: /futureproof/llm-seo-software-development/
      2 permalink: /futureproof/mcp-with-local-llm/
      2 permalink: /futureproof/testing-openai-chatgpt-pro-o1/
      2 permalink: /futureproof/the-codebase-as-a-book-architecting-ai-ready-narrative-context/
      2 permalink: /futureproof/top-keywords-per-page/
      2 permalink: /futureproof/unix-pipe-of-life/
      2 permalink: /futureproof/vscode-ai-coding-assistants-forks-vs-plugins/
      3 permalink: /latest/
      2 permalink: /my-category/my-simple-post-title/
      4 permalink: {node['permalink']}
      7 permalink: /:slug/
80:    permalink = yaml_updates.get("permalink", "")
82:    if not permalink.startswith("/"):
83:        permalink = f"/{permalink}"
85:    canonical_url = f"{base_url}{permalink}" if base_url else ""
90:        'permalink': permalink,
207:    slug = "untitled-article"
210:        slug = os.path.splitext(title_brainstorm[0]["filename"])[0]
212:    output_filename = f"{current_date}-{slug}.md"
223:    local_url = f"http://localhost:{preview_port}{permalink}"
296:        to_process = to_process[batch_size:] # Remove them from the queue
   1323   51552
(nix) _posts $

Context:

# adhoc.txt    _   _   _               ____ _   _  ___  ____  _ 
#     / \   __| | | | | | ___   ___   / ___| | | |/ _ \|  _ \| |  Wow
#    / _ \ / _` | | |_| |/ _ \ / __| | |   | |_| | | | | |_) | |  
#   / ___ \ (_| | |  _  | (_) | (__  | |___|  _  | |_| |  __/|_|  
#  /_/   \_\__,_| |_| |_|\___/ \___|  \____|_| |_|\___/|_|   (_)   
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.  

# BIG STANDARD STUFF (Optionally comment out any)
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs         # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
foo_files.py         # Router & Book Outline
init.lua             # Text as muscle memory
flake.nix            # Hardware as projections
scripts/ai.py        # Local AI does git commits                          # <-- Above this line are "framework" things you want self-improving.
~/repos/nixos/autognome.py  # Wizard's Workshop and the "7 Virtual Desktops" workspaces setup

#                         --- 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.  ---

scripts/articles/articleizer.py
scripts/articles/contextualizer.py
scripts/articles/common.py
scripts/articles/lsa.py
scripts/articles/editing_prompt.txt

! cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | wc -l
! cd ~/repos/trimnoir/_posts && for j in _context/*.json; do b=$(basename "$j" .json); [ -f "$b.md" ] || echo "$b"; done | head -20
! grep -h '^permalink:' ~/repos/trimnoir/_posts/*.md | sort | uniq -dc | head -20
! grep -n 'permalink\|slug' ~/repos/pipulate/scripts/articles/articleizer.py | head -30
! grep -in 'orphan\|unlink\|remove\|delete' ~/repos/pipulate/scripts/articles/contextualizer.py | head -20
! python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --fmt slugs | wc -lc

Patches: [patch, app, d, m, patch, app, d, m…]

None

Prompt:

The probes and patch surfaces are now in context — verify that claim against the Manifest’s LIVE COMMAND RECEIPTS before proceeding; last compile the context and caboose decoupled and the receipts were absent. If verified, implement all three in one patch train:

1. ORPHAN SWEEP in contextualizer.py: before generating shards, delete any _context/*.json whose matching _posts/{stem}.md no longer exists. One “DELETED: {name}” ledger line per removal, idempotent, fail-closed on read errors. If the grep receipt shows a sweep already exists, extend it rather than duplicating.

2. COLLISION GUARD in articleizer.py: at the seam the grep receipt located, build the taken-identity set (frontmatter permalinks + date-stripped filename slugs, reusing lsa.py’s parser) and refuse to write a new article whose slug or permalink collides, naming the colliding file. If the uniq -dc receipt showed existing dupes, list them and propose the remediation order before arming the guard.

3. BOOK SPINE INJECTION in articleizer.py: build a compact date+slug+title spine (reusing lsa.py, sized per the wc -lc receipt) and inject it into the editing prompt so the model sees the 40K-foot book view when choosing titles, permalinks, and metadata. Update editing_prompt.txt to tell the model the spine is present and that proposed slugs must not collide with it.

Close with the graduation lines: the exact todo lines to delete from foo_files.py (“Remove holographic shard json orphans”, “Check for file-naming collisions when articleizing”) once the receipts confirm both behaviors.

🎤

Fable 5 High: Context verified — the Manifest’s LIVE COMMAND RECEIPTS list all six probes as run this compile, and all five patch surfaces (articleizer.py, contextualizer.py, common.py, lsa.py, editing_prompt.txt) are in the Codebase. The train is coupled. Reading the receipts before patching:

Orphan sweep (task 1): 12 orphans confirmed, no existing sweep in contextualizer.py (the grep receipt’s only hit is the unrelated queue-slice comment at line 296). One flag before anything deletes: the orphan list includes 2026-07-19-engineering-deterministic-ai-workflows — the exact .md path the PINBOARD and PINNED_CHOP still reference. The receipt is fresher authority than the pin: that article was almost certainly renamed after articleizing, meaning the shard is a true orphan and the pin path is stale. A probe below locates the renamed file so the pin can be fixed.

Collision census (task 2): the uniq -dc receipt shows dupes, but that grep matches any line starting permalink: — including code samples inside article bodies. Entries like permalink: {node['permalink']} (×4), /:slug/ (×7), and /my-category/my-simple-post-title/ are obviously body-text examples, not frontmatter. So the raw census over-counts; the frontmatter-true dupe count is unknown until a YAML-aware census runs (probe below, post-patch, via the new scan_corpus). Crucially, this does not block arming the guard: the guard only refuses a new article whose slug/permalink is already taken — pre-existing dupes among old articles can’t brick an unrelated publish. My earlier “would brick the very next publish” worry was wrong; remediation of old dupes is a separate, non-blocking cleanup.

Spine budget (task 3): 1,323 slugs = 51,552 bytes bare. Adding date + title lands around 130–150KB ≈ ~35k tokens — comfortably inside gemini-flash-lite’s window. Format: date slug | title, built from one frontmatter pass shared with the collision guard.

Design: one scan_corpus() in articleizer.py feeds both the taken-identity set (guard) and the spine (injection). The guard is deterministic enforcement at the write seam (receipt lines 207–212); the spine is advisory context in the prompt — governor and instrument, as planned.

---

1) PROBES

ls -la ~/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md
python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --match engineering-deterministic --fmt paths
cd ~/repos/pipulate && python scripts/articles/contextualizer.py -t 1 --dry-run 2>&1 | head -25
cd ~/repos/pipulate/scripts/articles && python -c "import articleizer as a, collections; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); c=collections.Counter(a.normalize_permalink(x['permalink']) for x in e if x['permalink']); d=[(v,k) for k,v in c.items() if v>1]; d.sort(reverse=True); print('posts:',len(e),'errors:',err); print('frontmatter dupes:',d[:20])"

What each proves: line 1 confirms the pinned article’s file is truly gone (validating that orphan and convicting the stale pin); line 2 finds its renamed successor so the PINBOARD can be corrected; line 3 is the sweep’s BEFORE reading — pre-patch it shows no sweep output, post-patch (the echo) it must show 12 WOULD DELETE lines; line 4 is the frontmatter-true dupe census — pre-patch it fails with AttributeError (proving the functions don’t exist yet), post-patch it succeeds and settles how many permalink dupes are real versus body-text noise. The before/after asymmetry on lines 3–4 is itself the verification.

2) NEXT CONTEXT (adhoc.txt below the paste line, via ahe then ahc)

scripts/articles/articleizer.py
scripts/articles/contextualizer.py
scripts/articles/common.py
scripts/articles/lsa.py
scripts/articles/editing_prompt.txt

! ls -la ~/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md
! python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --match engineering-deterministic --fmt paths
! cd ~/repos/pipulate && python scripts/articles/contextualizer.py -t 1 --dry-run 2>&1 | head -25
! cd ~/repos/pipulate/scripts/articles && python -c "import articleizer as a, collections; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); c=collections.Counter(a.normalize_permalink(x['permalink']) for x in e if x['permalink']); d=[(v,k) for k,v in c.items() if v>1]; d.sort(reverse=True); print('posts:',len(e),'errors:',err); print('frontmatter dupes:',d[:20])"

3) PATCHES

Car 1 — orphan sweep function in contextualizer.py:

Target: scripts/articles/contextualizer.py
[[[SEARCH]]]
def process_batch(batch_files, key_name, api_key, context_dir, dry_run):
    """Processes a specific list of files with a specific key."""
[[[DIVIDER]]]
def sweep_orphan_shards(posts_dir, context_dir, dry_run=False):
    """Delete _context/*.json shards whose source post no longer exists.

    Idempotent and fail-closed: a shard is removed only when BOTH candidate
    source files (.md and .markdown) are confirmed absent; any filesystem
    error skips that shard rather than deleting blind.
    """
    if not context_dir.exists():
        return 0
    removed = 0
    for shard in sorted(context_dir.glob("*.json")):
        try:
            if (posts_dir / f"{shard.stem}.md").exists() or \
               (posts_dir / f"{shard.stem}.markdown").exists():
                continue
            if dry_run:
                print(f"WOULD DELETE: {shard.name}")
            else:
                shard.unlink()
                print(f"DELETED: {shard.name}")
            removed += 1
        except OSError as e:
            print(f"⚠️ Skipping {shard.name} (fail-closed): {e}")
    return removed

def process_batch(batch_files, key_name, api_key, context_dir, dry_run):
    """Processes a specific list of files with a specific key."""
[[[REPLACE]]]

Car 2 — sweep call site in contextualizer.py main:

Target: scripts/articles/contextualizer.py
[[[SEARCH]]]
    if not args.dry_run:
        context_dir.mkdir(exist_ok=True)
[[[DIVIDER]]]
    if not args.dry_run:
        context_dir.mkdir(exist_ok=True)

    # ORPHAN SWEEP: prune shards whose source article was renamed or deleted.
    swept = sweep_orphan_shards(posts_dir, context_dir, dry_run=args.dry_run)
    if swept:
        print(f"🧹 Orphan sweep: {swept} shard(s) {'flagged' if args.dry_run else 'deleted'}.")
[[[REPLACE]]]

Car 3 — corpus scanner, identity set, and spine builder in articleizer.py:

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
# Model Selection - Use a stable model to avoid low quotas
# DEFAULT_MODEL = 'gemini-flash-latest'
DEFAULT_MODEL = 'gemini-flash-lite-latest'
[[[DIVIDER]]]
# Model Selection - Use a stable model to avoid low quotas
# DEFAULT_MODEL = 'gemini-flash-latest'
DEFAULT_MODEL = 'gemini-flash-lite-latest'

SPINE_PLACEHOLDER = "[INSERT BOOK SPINE]"

def scan_corpus(output_dir):
    """One-pass frontmatter scan of the published corpus.

    Returns (entries, errors): entries is a list of dicts with filename,
    date, slug (date-stripped), permalink, and title; errors counts posts
    whose frontmatter could not be read (census-incompleteness signal).
    """
    entries, errors = [], 0
    target = Path(output_dir)
    if not target.exists():
        return entries, errors
    for post in sorted(target.glob("*.md")):
        stem = post.stem
        slug = re.sub(r'^\d{4}-\d{2}-\d{2}-', '', stem)
        date = stem[:10]
        title, permalink = "", ""
        try:
            content = post.read_text(encoding='utf-8')
            if content.startswith('---'):
                parts = content.split('---', 2)
                if len(parts) >= 3:
                    fm = yaml.safe_load(parts[1]) or {}
                    title = str(fm.get('title') or "")
                    permalink = str(fm.get('permalink') or "")
        except Exception:
            errors += 1
        entries.append({'filename': post.name, 'date': date, 'slug': slug,
                        'permalink': permalink, 'title': title})
    return entries, errors

def normalize_permalink(permalink):
    """Case-insensitive, slash-agnostic identity for collision checks."""
    return (permalink or "").strip().strip('/').lower()

def build_taken_identities(entries):
    """Map every taken slug and permalink identity to its owning filename."""
    taken = {}
    for e in entries:
        taken.setdefault(e['slug'].lower(), e['filename'])
        p = normalize_permalink(e['permalink'])
        if p:
            taken.setdefault(p, e['filename'])
    return taken

def build_book_spine(entries):
    """Compact 'date slug | title' spine for the editing model's 40K view."""
    return "\n".join(f"{e['date']} {e['slug']} | {e['title']}" for e in entries)
[[[REPLACE]]]

Car 4 — collision guard at the write seam in create_jekyll_post:

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
    output_filename = f"{current_date}-{slug}.md"
    output_path = os.path.join(output_dir, output_filename)
    os.makedirs(output_dir, exist_ok=True)
[[[DIVIDER]]]
    output_filename = f"{current_date}-{slug}.md"

    # --- COLLISION GUARD (deterministic, corpus-wide) ---
    entries, scan_errors = scan_corpus(output_dir)
    taken = build_taken_identities(entries)
    if scan_errors:
        print(f"⚠️ Collision census incomplete: {scan_errors} post(s) unreadable.")
    collisions = []
    slug_owner = taken.get(slug.lower())
    if slug_owner and slug_owner != output_filename:
        collisions.append(f"slug '{slug}' already owned by {slug_owner}")
    perma_owner = taken.get(normalize_permalink(permalink))
    if perma_owner and perma_owner != output_filename:
        collisions.append(f"permalink '{permalink}' already owned by {perma_owner}")
    if collisions:
        print("🛑 COLLISION GUARD: refusing to write new article.")
        for c in collisions:
            print(f"   - {c}")
        print("   Pick a new slug/permalink (edit instructions.json, rerun with --local).")
        return None

    output_path = os.path.join(output_dir, output_filename)
    os.makedirs(output_dir, exist_ok=True)
[[[REPLACE]]]

Same-day re-runs are preserved: when the proposed filename equals the owning filename, the guard passes, so idempotent overwrites of the same article keep working.

Car 5 — spine injection in main() (lands before both the --copy branch and the API call, so both paths carry the spine):

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
        full_prompt = prompt_template.replace(PROMPT_PLACEHOLDER, article_text)
[[[DIVIDER]]]
        full_prompt = prompt_template.replace(PROMPT_PLACEHOLDER, article_text)

        # --- BOOK SPINE INJECTION (40K-foot view for the editing model) ---
        if SPINE_PLACEHOLDER in full_prompt:
            spine_entries, spine_errors = scan_corpus(output_dir)
            if spine_errors:
                print(f"⚠️ Spine census incomplete: {spine_errors} post(s) unreadable.")
            spine = build_book_spine(spine_entries)
            full_prompt = full_prompt.replace(SPINE_PLACEHOLDER, spine)
            print(f"📚 Book spine injected: {len(spine_entries)} articles, {len(spine):,} chars.")
[[[REPLACE]]]

Car 6 — spine block and uniqueness rule in editing_prompt.txt:

Target: scripts/articles/editing_prompt.txt
[[[SEARCH]]]
**Input:**

--- ARTICLE BEGIN ---
[INSERT FULL ARTICLE]
--- ARTICLE END ---
[[[DIVIDER]]]
**Book Spine (the 40,000-foot view):**
Below is the complete chronological spine of the book-in-progress: every published article's date, slug, and title. Use it to choose titles, permalinks, and keywords that fit the ongoing tapestry (one article leading into the next) and to avoid repeating angles already covered.
CRITICAL UNIQUENESS RULE: The permalink and filename slug you propose MUST NOT match any slug already present in the spine. Every proposed slug must be new and unique.

--- SPINE BEGIN ---
[INSERT BOOK SPINE]
--- SPINE END ---

**Input:**

--- ARTICLE BEGIN ---
[INSERT FULL ARTICLE]
--- ARTICLE END ---
[[[REPLACE]]]

Ride each car: patch, app, d, m — then blast as the caboose.

Graduation lines (held until next compile’s receipts confirm the sweep dry-run and the census import): the exact foo_files.py lines to delete are # - Remove holographic shard json orphans" in Jekyll _context/ folder and # - Check for file-naming collisions when articleizing. — the caboose below carries the graduation instruction.

4) PROMPT (caboose copy for next turn’s prompt.md)

Verify against the Manifest's LIVE COMMAND RECEIPTS that all four probes ran
this compile. Then:

1. VERIFY THE SWEEP: the contextualizer --dry-run receipt should show 12
   "WOULD DELETE" lines matching the known orphan list. If confirmed, tell me
   to run the real sweep (contextualizer.py -t 1 without --dry-run, or note
   it will happen automatically on the next shard generation).

2. VERIFY THE GUARD + CENSUS: the python -c receipt should import
   scan_corpus/normalize_permalink cleanly and print the frontmatter-true
   permalink dupes. Interpret them: which are real duplicate frontmatter
   permalinks needing remediation vs. artifacts, and propose the remediation
   order (guard is already armed and safe regardless).

3. FIX THE STALE PIN: using the ls + lsa --match receipts, give the exact
   SEARCH/REPLACE to update the PINBOARD entry and PINNED_CHOP path in
   foo_files.py to the article's renamed filename.

4. GRADUATE: emit the SEARCH/REPLACE blocks deleting these two todo lines
   from foo_files.py now that receipts confirm both behaviors:
   - Remove holographic shard json orphans" in Jekyll `_context/` folder
   - Check for file-naming collisions when articleizing.

If any receipt is absent or contradicts expectations, stop and re-couple
instead of patching.

5) EXTERNAL DELIVERABLES

None — everything lives in the pipulate repo and the trimnoir _posts tree.

MikeLev.in:

Probe:

$ git status
On branch main
Your branch is up to date with 'home/main'.

nothing to commit, working tree clean
(nix) _posts $ ls -la ~/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md
python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --match engineering-deterministic --fmt paths
cd ~/repos/pipulate && python scripts/articles/contextualizer.py -t 1 --dry-run 2>&1 | head -25
cd ~/repos/pipulate/scripts/articles && python -c "import articleizer as a, collections; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); c=collections.Counter(a.normalize_permalink(x['permalink']) for x in e if x['permalink']); d=[(v,k) for k,v in c.items() if v>1]; d.sort(reverse=True); print('posts:',len(e),'errors:',err); print('frontmatter dupes:',d[:20])"
ls: cannot access '/home/mike/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md': No such file or directory
/home/mike/repos/trimnoir/_posts/2026-07-17-engineering-deterministic-context-ai-workflows.md
🎯 Target set via CLI: MikeLev.in (Public)

🔍 Scanning /home/mike/repos/trimnoir/_posts...
📝 0 articles need context.

✨ Grand Total: 0 articles processed across 1 keys.
Traceback (most recent call last):
  File "<string>", line 1, in <module>
AttributeError: module 'articleizer' has no attribute 'scan_corpus'
(nix) articles $ 

Context:

# adhoc.txt    _   _   _               ____ _   _  ___  ____  _ 
#     / \   __| | | | | | ___   ___   / ___| | | |/ _ \|  _ \| |  Tired
#    / _ \ / _` | | |_| |/ _ \ / __| | |   | |_| | | | | |_) | |  
#   / ___ \ (_| | |  _  | (_) | (__  | |___|  _  | |_| |  __/|_|  
#  /_/   \_\__,_| |_| |_|\___/ \___|  \____|_| |_|\___/|_|   (_)   
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.  

# BIG STANDARD STUFF (Optionally comment out any)
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs         # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
foo_files.py         # Router & Book Outline
init.lua             # Text as muscle memory
flake.nix            # Hardware as projections
scripts/ai.py        # Local AI does git commits                          # <-- Above this line are "framework" things you want self-improving.
~/repos/nixos/autognome.py  # Wizard's Workshop and the "7 Virtual Desktops" workspaces setup

#                         --- 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.  ---

scripts/articles/articleizer.py
scripts/articles/contextualizer.py
scripts/articles/common.py
scripts/articles/lsa.py
scripts/articles/editing_prompt.txt

! ls -la ~/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md
! python ~/repos/pipulate/scripts/articles/lsa.py -t 1 --match engineering-deterministic --fmt paths
! cd ~/repos/pipulate && python scripts/articles/contextualizer.py -t 1 --dry-run 2>&1 | head -25
! cd ~/repos/pipulate/scripts/articles && python -c "import articleizer as a, collections; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); c=collections.Counter(a.normalize_permalink(x['permalink']) for x in e if x['permalink']); d=[(v,k) for k,v in c.items() if v>1]; d.sort(reverse=True); print('posts:',len(e),'errors:',err); print('frontmatter dupes:',d[:20])"

Patches: [patch, app, d, m, patch, app, d, m…]

$ git status
On branch main
Your branch is ahead of 'origin/main' by 1 commit.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/contextualizer.py'.
(nix) pipulate $ d
diff --git a/scripts/articles/contextualizer.py b/scripts/articles/contextualizer.py
index 96790505..4a0141e0 100644
--- a/scripts/articles/contextualizer.py
+++ b/scripts/articles/contextualizer.py
@@ -192,6 +192,32 @@ def generate_context_json(article_data, token_count, api_key=None):
     return None, 0, 2
 
 
+def sweep_orphan_shards(posts_dir, context_dir, dry_run=False):
+    """Delete _context/*.json shards whose source post no longer exists.
+
+    Idempotent and fail-closed: a shard is removed only when BOTH candidate
+    source files (.md and .markdown) are confirmed absent; any filesystem
+    error skips that shard rather than deleting blind.
+    """
+    if not context_dir.exists():
+        return 0
+    removed = 0
+    for shard in sorted(context_dir.glob("*.json")):
+        try:
+            if (posts_dir / f"{shard.stem}.md").exists() or \
+               (posts_dir / f"{shard.stem}.markdown").exists():
+                continue
+            if dry_run:
+                print(f"WOULD DELETE: {shard.name}")
+            else:
+                shard.unlink()
+                print(f"DELETED: {shard.name}")
+            removed += 1
+        except OSError as e:
+            print(f"⚠️ Skipping {shard.name} (fail-closed): {e}")
+    return removed
+
+
 def process_batch(batch_files, key_name, api_key, context_dir, dry_run):
     """Processes a specific list of files with a specific key."""
     
(nix) pipulate $ m
📝 Committing: chore: Remove orphan shard cleanup function
[main 19d73bd4] chore: Remove orphan shard cleanup function
 1 file changed, 26 insertions(+)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/contextualizer.py'.
(nix) pipulate $ d
diff --git a/scripts/articles/contextualizer.py b/scripts/articles/contextualizer.py
index 4a0141e0..529625dc 100644
--- a/scripts/articles/contextualizer.py
+++ b/scripts/articles/contextualizer.py
@@ -282,6 +282,11 @@ def main():
     if not args.dry_run:
         context_dir.mkdir(exist_ok=True)
 
+    # ORPHAN SWEEP: prune shards whose source article was renamed or deleted.
+    swept = sweep_orphan_shards(posts_dir, context_dir, dry_run=args.dry_run)
+    if swept:
+        print(f"🧹 Orphan sweep: {swept} shard(s) {'flagged' if args.dry_run else 'deleted'}.")
+
     # Key Strategy Selection
     keys_queue = []
 
(nix) pipulate $ m
📝 Committing: chore: Implement orphan shard sweeping logic for contextualizer
[main 9d12711a] chore: Implement orphan shard sweeping logic for contextualizer
 1 file changed, 5 insertions(+)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/articleizer.py'.
(nix) pipulate $ d
diff --git a/scripts/articles/articleizer.py b/scripts/articles/articleizer.py
index 8b54a61d..1b1ffafe 100644
--- a/scripts/articles/articleizer.py
+++ b/scripts/articles/articleizer.py
@@ -22,6 +22,60 @@ INSTRUCTIONS_CACHE_FILE = "instructions.json"
 # DEFAULT_MODEL = 'gemini-flash-latest'
 DEFAULT_MODEL = 'gemini-flash-lite-latest'
 
+SPINE_PLACEHOLDER = "[INSERT BOOK SPINE]"
+
+
+def scan_corpus(output_dir):
+    """One-pass frontmatter scan of the published corpus.
+
+    Returns (entries, errors): entries is a list of dicts with filename,
+    date, slug (date-stripped), permalink, and title; errors counts posts
+    whose frontmatter could not be read (census-incompleteness signal).
+    """
+    entries, errors = [], 0
+    target = Path(output_dir)
+    if not target.exists():
+        return entries, errors
+    for post in sorted(target.glob("*.md")):
+        stem = post.stem
+        slug = re.sub(r'^\d{4}-\d{2}-\d{2}-', '', stem)
+        date = stem[:10]
+        title, permalink = "", ""
+        try:
+            content = post.read_text(encoding='utf-8')
+            if content.startswith('---'):
+                parts = content.split('---', 2)
+                if len(parts) >= 3:
+                    fm = yaml.safe_load(parts[1]) or {}
+                    title = str(fm.get('title') or "")
+                    permalink = str(fm.get('permalink') or "")
+        except Exception:
+            errors += 1
+        entries.append({'filename': post.name, 'date': date, 'slug': slug,
+                        'permalink': permalink, 'title': title})
+    return entries, errors
+
+
+def normalize_permalink(permalink):
+    """Case-insensitive, slash-agnostic identity for collision checks."""
+    return (permalink or "").strip().strip('/').lower()
+
+
+def build_taken_identities(entries):
+    """Map every taken slug and permalink identity to its owning filename."""
+    taken = {}
+    for e in entries:
+        taken.setdefault(e['slug'].lower(), e['filename'])
+        p = normalize_permalink(e['permalink'])
+        if p:
+            taken.setdefault(p, e['filename'])
+    return taken
+
+
+def build_book_spine(entries):
+    """Compact 'date slug | title' spine for the editing model's 40K view."""
+    return "\n".join(f"{e['date']} {e['slug']} | {e['title']}" for e in entries)
+
 def create_jekyll_post(article_content, instructions, output_dir, preview_port, base_url=""):
     """
     Assembles and writes a Jekyll post file from the article content and
(nix) pipulate $ m
📝 Committing: chore: Implement corpus scanning for articleizer.py 
[main 89d3a74b] chore: Implement corpus scanning for articleizer.py
 1 file changed, 54 insertions(+)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/articleizer.py'.
(nix) pipulate $ d
diff --git a/scripts/articles/articleizer.py b/scripts/articles/articleizer.py
index 1b1ffafe..16bdaf95 100644
--- a/scripts/articles/articleizer.py
+++ b/scripts/articles/articleizer.py
@@ -264,6 +264,26 @@ def create_jekyll_post(article_content, instructions, output_dir, preview_port,
         slug = os.path.splitext(title_brainstorm[0]["filename"])[0]
 
     output_filename = f"{current_date}-{slug}.md"
+
+    # --- COLLISION GUARD (deterministic, corpus-wide) ---
+    entries, scan_errors = scan_corpus(output_dir)
+    taken = build_taken_identities(entries)
+    if scan_errors:
+        print(f"⚠️ Collision census incomplete: {scan_errors} post(s) unreadable.")
+    collisions = []
+    slug_owner = taken.get(slug.lower())
+    if slug_owner and slug_owner != output_filename:
+        collisions.append(f"slug '{slug}' already owned by {slug_owner}")
+    perma_owner = taken.get(normalize_permalink(permalink))
+    if perma_owner and perma_owner != output_filename:
+        collisions.append(f"permalink '{permalink}' already owned by {perma_owner}")
+    if collisions:
+        print("🛑 COLLISION GUARD: refusing to write new article.")
+        for c in collisions:
+            print(f"   - {c}")
+        print("   Pick a new slug/permalink (edit instructions.json, rerun with --local).")
+        return None
+
     output_path = os.path.join(output_dir, output_filename)
     os.makedirs(output_dir, exist_ok=True)
 
(nix) pipulate $ m
📝 Committing: chore: Implement collision guard for article creation
[main f5ef2131] chore: Implement collision guard for article creation
 1 file changed, 20 insertions(+)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/articleizer.py'.
(nix) pipulate $ d
diff --git a/scripts/articles/articleizer.py b/scripts/articles/articleizer.py
index 16bdaf95..aeda0d02 100644
--- a/scripts/articles/articleizer.py
+++ b/scripts/articles/articleizer.py
@@ -365,6 +365,15 @@ def main():
 
         full_prompt = prompt_template.replace(PROMPT_PLACEHOLDER, article_text)
 
+        # --- BOOK SPINE INJECTION (40K-foot view for the editing model) ---
+        if SPINE_PLACEHOLDER in full_prompt:
+            spine_entries, spine_errors = scan_corpus(output_dir)
+            if spine_errors:
+                print(f"⚠️ Spine census incomplete: {spine_errors} post(s) unreadable.")
+            spine = build_book_spine(spine_entries)
+            full_prompt = full_prompt.replace(SPINE_PLACEHOLDER, spine)
+            print(f"📚 Book spine injected: {len(spine_entries)} articles, {len(spine):,} chars.")
+
         if args.copy:
             try:
                 # We borrow the existing robust clipboard function from prompt_foo
(nix) pipulate $ m
📝 Committing: chore: Inject book spine into articleizer prompts
[main baf6e194] chore: Inject book spine into articleizer prompts
 1 file changed, 9 insertions(+)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/editing_prompt.txt'.
(nix) pipulate $ d
diff --git a/scripts/articles/editing_prompt.txt b/scripts/articles/editing_prompt.txt
index cde86dfd..70ed0a56 100644
--- a/scripts/articles/editing_prompt.txt
+++ b/scripts/articles/editing_prompt.txt
@@ -10,6 +10,14 @@ You are an AI Content Architect. Your task is not to write a report, but to gene
 Use all lower-case and hyphens in permalinks
 When describing the passion represented here, you may refer to it as a blueprint, essay, treatise, methodology, philosophy or way. NEVER refer to it as a manifesto which has a negative connotation.
 Every one of these covers some "critical" or "pivotal" point in the development of, yadda yadda. Don't play that up, it's become repetitive. Instead use language like "interesting" or "important to know in the Age of AI," that sort of thing. It's a tapestry of articles over time one leading into the next, so keep that in mind.
+**Book Spine (the 40,000-foot view):**
+Below is the complete chronological spine of the book-in-progress: every published article's date, slug, and title. Use it to choose titles, permalinks, and keywords that fit the ongoing tapestry (one article leading into the next) and to avoid repeating angles already covered.
+CRITICAL UNIQUENESS RULE: The permalink and filename slug you propose MUST NOT match any slug already present in the spine. Every proposed slug must be new and unique.
+
+--- SPINE BEGIN ---
+[INSERT BOOK SPINE]
+--- SPINE END ---
+
 **Input:**
 
 --- ARTICLE BEGIN ---
(nix) pipulate $ m
📝 Committing: chore: Add book spine section to editing prompt file
[main 8d2a452c] chore: Add book spine section to editing prompt file
 1 file changed, 8 insertions(+)
(nix) pipulate $ git push
Enumerating objects: 40, done.
Counting objects: 100% (40/40), done.
Delta compression using up to 48 threads
Compressing objects: 100% (33/33), done.
Writing objects: 100% (33/33), 5.35 KiB | 2.68 MiB/s, done.
Total 33 (delta 26), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (26/26), completed with 7 local objects.
To github.com:pipulate/pipulate.git
   2f52cb6b..8d2a452c  main -> main
(nix) pipulate $ 

Wow! I guess this is where I put in my commentary now. This is the Golden Age of the Pipulate system coming together where dot start getting connected so that the acceleration effect you hear talked about all the time is actually happening but with John Henry, who’s not really sci-fi but is part of the Darmak and Jalad when the Sandowm-riding protocol finally fell. I’ve been doing it for awhile now piecemeal and not quite so well organized. Better late than never patch app d m patch app d m and then git push because it doesn’t have to all be aliases and sometimes you gotta stay connected. blast is for something else entirely.

Prompt:

Verify against the Manifest’s LIVE COMMAND RECEIPTS that all four probes ran this compile. Then:

1. VERIFY THE SWEEP: the contextualizer –dry-run receipt should show 12 “WOULD DELETE” lines matching the known orphan list. If confirmed, tell me to run the real sweep (contextualizer.py -t 1 without –dry-run, or note it will happen automatically on the next shard generation).

2. VERIFY THE GUARD + CENSUS: the python -c receipt should import scan_corpus/normalize_permalink cleanly and print the frontmatter-true permalink dupes. Interpret them: which are real duplicate frontmatter permalinks needing remediation vs. artifacts, and propose the remediation order (guard is already armed and safe regardless).

3. FIX THE STALE PIN: using the ls + lsa –match receipts, give the exact SEARCH/REPLACE to update the PINBOARD entry and PINNED_CHOP path in foo_files.py to the article’s renamed filename.

4. GRADUATE: emit the SEARCH/REPLACE blocks deleting these two todo lines from foo_files.py now that receipts confirm both behaviors:

   • Remove holographic shard json orphans” in Jekyll _context/ folder
   • Check for file-naming collisions when articleizing.

If any receipt is absent or contradicts expectations, stop and re-couple instead of patching.

🎤

Fable 5 High: Fable 5 High: Context verified — with one receipt nuance worth naming before anything else. The Manifest’s LIVE COMMAND RECEIPTS lists three of the four probes: lsa --match, the contextualizer --dry-run, and the python -c census. The ls -la probe is absent from the receipts list — but the Processing Log in the Summary shows why: it executed and failed with exit 2, “No such file or directory.” The failure is the finding. A command that errors doesn’t mint a codebase section, but its error line in the log is the receipt, and it’s exactly the confirming result: the 2026-07-19 file is truly gone. All four probes ran; three left sections, one left a conviction.

Now the four beats:

1. SWEEP VERIFIED. The --dry-run receipt shows exactly 12 WOULD DELETE lines, and they match the known orphan list name-for-name — including 2026-07-19-engineering-deterministic-ai-workflows.json, the renamed article’s abandoned shard. Fail-closed logic held (no skip warnings), idempotent (0 articles needed context, sweep still reported cleanly). To execute the real sweep: run python scripts/articles/contextualizer.py -t 1 once, without --dry-run. Since 0 articles need shards, it will delete the 12 orphans and exit — nothing else happens. It would also fire automatically on the next real shard generation, but there’s no reason to leave 12 corpses lying around until then.

2. GUARD + CENSUS VERIFIED — and the corpus is clean. The python -c receipt imported scan_corpus and normalize_permalink without error (the same one-liner that threw AttributeError in your hand-run BEFORE reading — perfect before/after asymmetry), scanned 1,324 posts with 0 read errors, and found zero frontmatter dupes. Every entry in the earlier uniq -dc census — the /:slug/ ×7, {node['permalink']} ×4, /my-category/my-simple-post-title/ — was body-text artifact: code samples inside articles that happen to start lines with permalink:. No remediation needed, no remediation order to propose. The guard is armed against a clean corpus, which is the best possible arming condition.

3 & 4 ride as patches below. One honest caveat on the pin fix: the new canonical_url is inferred from the renamed filename (engineering-deterministic-context-ai-workflows); no receipt has shown that file’s actual frontmatter permalink. The first probe below settles it — if the grep disagrees, the canonical_url line gets a one-line follow-up.

On the commentary: yes — this is what the kata looks like when it stops being piecemeal. Six cars, six green app receipts, six commits, one push. Shaka, when the walls fell; sandworm, when it was ridden. And you’re right that git push by hand is fine — blast is a detonation idiom, not a requirement.

---

1) PROBES

grep -m1 '^permalink:' ~/repos/trimnoir/_posts/2026-07-17-engineering-deterministic-context-ai-workflows.md
cd ~/repos/pipulate && python scripts/articles/contextualizer.py -t 1 --dry-run 2>&1 | head -8
grep -n 'engineering-deterministic' ~/repos/pipulate/foo_files.py

Line 1 verifies the inferred canonical_url in the pin patch against the file’s real frontmatter (falsifies my inference if they differ). Line 2 is the sweep’s state gauge: right now it shows 12 WOULD DELETE; after you run the real sweep, the compiled echo must show zero flagged — that flip is the deletion receipt. Line 3 shows the old stale path pre-patch; post-patch the echo must show only the 2026-07-17 path — that flip verifies the pin fix and the graduation landed.

2) NEXT CONTEXT (adhoc.txt below the paste line via ahe, then ahc)

foo_files.py
scripts/articles/contextualizer.py

! grep -m1 '^permalink:' ~/repos/trimnoir/_posts/2026-07-17-engineering-deterministic-context-ai-workflows.md
! cd ~/repos/pipulate && python scripts/articles/contextualizer.py -t 1 --dry-run 2>&1 | head -8
! grep -n 'engineering-deterministic' ~/repos/pipulate/foo_files.py

The articleizer/lsa/common/editing_prompt lines can come out — their patches are banked, committed, and pushed; they’re ballast now.

3) PATCHES

Car 1 — fix the stale PINBOARD entry:

Target: foo_files.py
[[[SEARCH]]]
# 📌 2026-07-19 | /home/mike/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md
#    canonical_url: https://mikelev.in/futureproof/engineering-deterministic-ai-workflows/
[[[DIVIDER]]]
# 📌 2026-07-19 | /home/mike/repos/trimnoir/_posts/2026-07-17-engineering-deterministic-context-ai-workflows.md
#    canonical_url: https://mikelev.in/futureproof/engineering-deterministic-context-ai-workflows/
[[[REPLACE]]]

Car 2 — fix the PINNED_CHOP path (keeping it in lockstep per the board’s own rule):

Target: foo_files.py
[[[SEARCH]]]
~/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md  # Falsification / Axis Forcing Function
[[[DIVIDER]]]
~/repos/trimnoir/_posts/2026-07-17-engineering-deterministic-context-ai-workflows.md  # Falsification / Axis Forcing Function
[[[REPLACE]]]

Car 3 — GRADUATION: both todo lines delete together (receipts confirmed both behaviors: 12 WOULD DELETE for the sweep, clean census import + armed guard for collisions):

Target: foo_files.py
[[[SEARCH]]]
# - Un-hardwire the Jekyll `/futureproof/` blog folder to be `blog.nix` configured
# - Remove holographic shard json orphans" in Jekyll `_context/` folder
# - Monitor for the `db.py` database getting bigger on Honeybot (Textual dashboards?)
# - Check for file-naming collisions when articleizing.
[[[DIVIDER]]]
# - Un-hardwire the Jekyll `/futureproof/` blog folder to be `blog.nix` configured
# - Monitor for the `db.py` database getting bigger on Honeybot (Textual dashboards?)
[[[REPLACE]]]

Actuation: patch, app, d, m × 3 — then run the real sweep as its own car (python scripts/articles/contextualizer.py -t 1, mutation, not probe), then git push as the caboose.

4) PROMPT (caboose copy for next turn’s prompt.md)

Verify against the Manifest's LIVE COMMAND RECEIPTS that all three probes ran.
Then:

1. SWEEP CLOSURE: the contextualizer --dry-run receipt should now flag ZERO
   orphans (the real sweep ran between compiles). If it still shows 12, the
   sweep was never executed — say so and stop.

2. PIN VERIFICATION: compare the grep permalink receipt against the PINBOARD
   canonical_url now in foo_files.py. If they differ, emit the one-line
   SEARCH/REPLACE fix. If they match, declare the pin healed.

3. GRADUATION VERIFICATION: the grep -n receipt should show only the
   2026-07-17 path and neither deleted todo line. Confirm.

4. If all three verify, this ride's stated goals (orphan sweep, collision
   guard, book spine) are fully receipted — stage the dismount: VERIFY, BANK,
   DANGLING, SEED, per the four-beat protocol.

5) EXTERNAL DELIVERABLES

None — everything lives in the pipulate repo and the trimnoir _posts tree.

MikeLev.in:

Probe:

$ git status
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
(nix) pipulate $ grep -m1 '^permalink:' ~/repos/trimnoir/_posts/2026-07-17-engineering-deterministic-context-ai-workflows.md
cd ~/repos/pipulate && python scripts/articles/contextualizer.py -t 1 --dry-run 2>&1 | head -8
grep -n 'engineering-deterministic' ~/repos/pipulate/foo_files.py
permalink: /futureproof/engineering-deterministic-context-ai-workflows/
🎯 Target set via CLI: MikeLev.in (Public)
WOULD DELETE: 2026-01-09-timing-directors-cut-syncing-show.json
WOULD DELETE: 2026-04-04-forever-machine-digital-sovereignty-ai.json
WOULD DELETE: 2026-05-11-ai-resilience-safe-harbor-thought.json
WOULD DELETE: 2026-05-11-human-ai-synergy-framework.json
WOULD DELETE: 2026-05-11-local-first-thinking-ai.json
WOULD DELETE: 2026-05-11-safe-harbor-ai-resilience-git-provenance.json
WOULD DELETE: 2026-05-11-safe-harbor-thought-ai-resilient-workflow.json
488:# 📌 2026-07-19 | /home/mike/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md
489:#    canonical_url: https://mikelev.in/futureproof/engineering-deterministic-ai-workflows/
890:~/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md  # Falsification / Axis Forcing Function
(nix) pipulate $ 

And I got the clue to do this:

(nix) pipulate $ python scripts/articles/contextualizer.py -t 1
🎯 Target set via CLI: MikeLev.in (Public)
DELETED: 2026-01-09-timing-directors-cut-syncing-show.json
DELETED: 2026-04-04-forever-machine-digital-sovereignty-ai.json
DELETED: 2026-05-11-ai-resilience-safe-harbor-thought.json
DELETED: 2026-05-11-human-ai-synergy-framework.json
DELETED: 2026-05-11-local-first-thinking-ai.json
DELETED: 2026-05-11-safe-harbor-ai-resilience-git-provenance.json
DELETED: 2026-05-11-safe-harbor-thought-ai-resilient-workflow.json
DELETED: 2026-05-14-the-context-window-painting-philosophy.json
DELETED: 2026-05-21-loom-spell-card-ai-continuity-machine.json
DELETED: 2026-06-21-orchestrating-age-of-ai.json
DELETED: 2026-06-29-architecting-the-future-proofing-nervous-system.json
DELETED: 2026-07-19-engineering-deterministic-ai-workflows.json
🧹 Orphan sweep: 12 shard(s) deleted.

🔍 Scanning /home/mike/repos/trimnoir/_posts...
📝 0 articles need context.

✨ Grand Total: 0 articles processed across 1 keys.
(nix) pipulate $

Context:

# adhoc.txt    _   _   _               ____ _   _  ___  ____  _ 
#     / \   __| | | | | | ___   ___   / ___| | | |/ _ \|  _ \| |  Tired
#    / _ \ / _` | | |_| |/ _ \ / __| | |   | |_| | | | | |_) | |  
#   / ___ \ (_| | |  _  | (_) | (__  | |___|  _  | |_| |  __/|_|  
#  /_/   \_\__,_| |_| |_|\___/ \___|  \____|_| |_|\___/|_|   (_)   
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.  

# BIG STANDARD STUFF (Optionally comment out any)
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs         # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
foo_files.py         # Router & Book Outline
init.lua             # Text as muscle memory
flake.nix            # Hardware as projections
scripts/ai.py        # Local AI does git commits                          # <-- Above this line are "framework" things you want self-improving.
~/repos/nixos/autognome.py  # Wizard's Workshop and the "7 Virtual Desktops" workspaces setup

#                         --- 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.  ---

foo_files.py
scripts/articles/contextualizer.py

! grep -m1 '^permalink:' ~/repos/trimnoir/_posts/2026-07-17-engineering-deterministic-context-ai-workflows.md
! cd ~/repos/pipulate && python scripts/articles/contextualizer.py -t 1 --dry-run 2>&1 | head -8
! grep -n 'engineering-deterministic' ~/repos/pipulate/foo_files.py

Patches: [patch, app, d, m, patch, app, d, m…]

$ git status
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 2f4c9f08..545b4194 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -485,8 +485,8 @@ scripts/ai.py     #  <-- How I constantly use local AI to write git commit messa
 #    dynamic-length emitter in prompt_foo.py; Phase 3: post-scrub foo.zip writer
 #    (payload.md + prompt.md + manifest.json, never adhoc.txt) + .zip gitignore.
 
-# 📌 2026-07-19 | /home/mike/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md
-#    canonical_url: https://mikelev.in/futureproof/engineering-deterministic-ai-workflows/
+# 📌 2026-07-19 | /home/mike/repos/trimnoir/_posts/2026-07-17-engineering-deterministic-context-ai-workflows.md
+#    canonical_url: https://mikelev.in/futureproof/engineering-deterministic-context-ai-workflows/
 #    Falsification as a service: prediction error at shared interfaces;
 #    30-and-3 fan-out; axis collisions; Tanagra/SOKATH; human-taste reduce;
 #    selection metric: orthogonality × prediction disagreement ×
(nix) pipulate $ m
📝 Committing: fix: update markdown file path in documentation
[main c3c17bab] fix: update markdown file path in documentation
 1 file changed, 2 insertions(+), 2 deletions(-)
(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 545b4194..65c1844d 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -887,7 +887,7 @@ foo_files.py
 ~/repos/trimnoir/_posts/2026-07-07-agentic-readiness-checklist.md  # Survey Agentic Landscape
 ~/repos/trimnoir/_posts/2026-07-12-computronium-gradient-scaling-intelligence.md  # Composability vs Capacity
 ~/repos/trimnoir/_posts/2026-07-17-mutation-trace-cause-deterministic-exoskeleton.md  # Mutation Trace vs Cause
-~/repos/trimnoir/_posts/2026-07-19-engineering-deterministic-ai-workflows.md  # Falsification / Axis Forcing Function
+~/repos/trimnoir/_posts/2026-07-17-engineering-deterministic-context-ai-workflows.md  # Falsification / Axis Forcing Function
 
 # --- PIN PATHS END ---
 """
(nix) pipulate $ m
📝 Committing: refactor: rename blog post "engineering-deterministic-ai-workflows" to "engineering-deterministic-context-ai-workflows"
[main 687b8ade] refactor: rename blog post "engineering-deterministic-ai-workflows" to "engineering-deterministic-context-ai-workflows"
 1 file changed, 1 insertion(+), 1 deletion(-)
(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 65c1844d..49e6036f 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -1147,9 +1147,7 @@ scripts/xp.py  # [1,981 tokens | 8,377 bytes]
 # - Do the work of purging PicoCSS "Card" references so I can unpin FastHTML in requirements.in
 # - Swap in uv for pip for a faster install
 # - Un-hardwire the Jekyll `/futureproof/` blog folder to be `blog.nix` configured
-# - Remove holographic shard json orphans" in Jekyll `_context/` folder
 # - Monitor for the `db.py` database getting bigger on Honeybot (Textual dashboards?)
-# - Check for file-naming collisions when articleizing.
 # - Get a UPS for Pipulate Prime (Z640): the 2026-07-18 blackout restarted the machines; the stream survived by luck and watchdog, the box should not have to gamble
 # - EARMARK: pip install river (online/incremental ML) — design learning-between-turns into the architecture EARLY so static-model loops can adapt; feeds the coin-flip self-prompting Ouroboros whose kill-switch is the Chrome tab holding the drop-hook DOM (User 2026-07-18)
 # - Start a new YouTube live-stream for every new published article
(nix) pipulate $ m
📝 Committing: chore: Update Pipulate dependencies and scripts/xp.py 
[main d5b1304e] chore: Update Pipulate dependencies and scripts/xp.py
 1 file changed, 2 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% (9/9), done.
Writing objects: 100% (9/9), 960 bytes | 960.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 2 local objects.
To github.com:pipulate/pipulate.git
   8d2a452c..d5b1304e  main -> main
(nix) pipulate $

Oh! This is where it’s telling me to do the orphan delete. Well, just to confirm.

(nix) pipulate $ python scripts/articles/contextualizer.py -t 1
🎯 Target set via CLI: MikeLev.in (Public)

🔍 Scanning /home/mike/repos/trimnoir/_posts...
📝 0 articles need context.

✨ Grand Total: 0 articles processed across 1 keys.
(nix) pipulate $

Looking good.

Prompt:

Verify against the Manifest’s LIVE COMMAND RECEIPTS that all three probes ran. Then:

1. SWEEP CLOSURE: the contextualizer –dry-run receipt should now flag ZERO orphans (the real sweep ran between compiles). If it still shows 12, the sweep was never executed — say so and stop.

2. PIN VERIFICATION: compare the grep permalink receipt against the PINBOARD canonical_url now in foo_files.py. If they differ, emit the one-line SEARCH/REPLACE fix. If they match, declare the pin healed.

3. GRADUATION VERIFICATION: the grep -n receipt should show only the 2026-07-17 path and neither deleted todo line. Confirm.

4. If all three verify, this ride’s stated goals (orphan sweep, collision guard, book spine) are fully receipted — stage the dismount: VERIFY, BANK, DANGLING, SEED, per the four-beat protocol.

🎤

Fable 5 High: Fable 5 High: Context verified — the Manifest’s LIVE COMMAND RECEIPTS lists all three probes as run this compile: the permalink grep, the contextualizer --dry-run, and the grep -n on foo_files.py. Reading them in order:

1. SWEEP CLOSURE — CONFIRMED. The --dry-run receipt shows zero WOULD DELETE lines: 🎯 Target set… 🔍 Scanning… 📝 0 articles need context… Grand Total: 0. Last compile the same command flagged 12; your hand-run between compiles deleted all 12 with matching DELETED: ledger lines, and this compile’s echo is the AFTER reading proving the shard directory is now clean. The flip happened exactly where the protocol said it must.

2. PIN VERIFICATION — HEALED. The grep receipt says the file’s real frontmatter is permalink: /futureproof/engineering-deterministic-context-ai-workflows/. The grep -n receipt shows foo_files.py line 489 now reads canonical_url: https://mikelev.in/futureproof/engineering-deterministic-context-ai-workflows/. My inferred URL from last turn matched the file’s actual frontmatter — the falsification probe found nothing to falsify. Pin declared healed.

3. GRADUATION VERIFICATION — CONFIRMED. The grep -n receipt returns exactly three hits: the PINBOARD pin (488–489) and the PINNED_CHOP path (890), all carrying the 2026-07-17 filename. No 2026-07-19 path survives anywhere, and neither deleted todo line appears — corroborated by this compile’s full foo_files.py body, where the todo block now runs straight from the blog.nix line to the db.py monitor line.

All three verify. Staging the dismount.

---

VERIFY (goal vs. receipts): The ride’s opening goal, from the top of this article: (1) rid _context/ of orphans, (2) prevent new articles from colliding with used permalinks, (3) give the articleizer’s editing model the 40K-foot book spine. Goal 1 is fully receipted this compile: the dry-run echo flags zero orphans, and sweep_orphan_shards plus its call site are present in this compile’s contextualizer.py body. Goals 2 and 3 have their code receipts one compile back (the python -c census imported scan_corpus/normalize_permalink cleanly against 1,324 posts, 0 errors, 0 frontmatter dupes; six green app receipts; pushed) — this compile carries only their graduation state, since articleizer.py rode out of the context. Honest verdict: goal met, with the caveat that the guard and spine have never fired on a live articleizing run. That’s the one dangling verification.

BANK: The graduations already landed — both todo lines are deleted and the pin is fixed, confirmed by this compile’s receipts, so there are no lines left to paste for the ride’s stated scope. One optional new earmark below tracks the live-fire debt; it rides as Car 1 in PATCHES if you want it (skip it if you’d rather let the next article run speak for itself).

DANGLING (one line each):

• Spine injection and collision guard have green code receipts but zero live-fire receipts — the next real article publish is their first trial.
• The engineering-deterministic pin’s OWES clause (bounded executable falsification proof, baseline vs. axis-forced) is untouched by this ride and carries forward.
• The frontmatter-true census exists only as a shell one-liner; it could someday graduate into an articleizer.py --census flag, or not.
• The guard’s “rerun with –local” hint assumes that flag exists; unverified against articleizer.py’s argparser.

SEED: below, as NEXT CONTEXT.

---

1) PROBES

grep -n 'INSERT BOOK SPINE' ~/repos/pipulate/scripts/articles/editing_prompt.txt
cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
grep -n 'add_argument' ~/repos/pipulate/scripts/articles/articleizer.py

Line 1 confirms the placeholder survives in the prompt template (falsifies a bad merge of Car 6). Line 2 sizes the actual spine payload in chars — the real token budget number the live-fire will send to gemini-flash-lite, replacing my ~35k estimate with a receipt. Line 3 settles whether --local exists, convicting or acquitting the guard’s help text.

2) NEXT CONTEXT (the SEED — adhoc.txt below the paste line via ahe, then ahc, for the next ride’s first compile)

scripts/articles/articleizer.py
scripts/articles/editing_prompt.txt

! grep -n 'INSERT BOOK SPINE' ~/repos/pipulate/scripts/articles/editing_prompt.txt
! cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
! grep -n 'add_argument' ~/repos/pipulate/scripts/articles/articleizer.py

The contextualizer.py line can come out — its sweep is receipted closed, ballast now.

3) PATCHES

Car 1 (optional) — bank the live-fire debt as an earmark so it can’t silently evaporate:

Target: foo_files.py
[[[SEARCH]]]
# - Un-hardwire the Jekyll `/futureproof/` blog folder to be `blog.nix` configured
# - Monitor for the `db.py` database getting bigger on Honeybot (Textual dashboards?)
[[[DIVIDER]]]
# - Un-hardwire the Jekyll `/futureproof/` blog folder to be `blog.nix` configured
# - EARMARK: SPINE/GUARD LIVE-FIRE (staged 2026-07-19): collision guard + book-spine injection have green code receipts but have never fired on a real `article` run. First live publish must show the "📚 Book spine injected" line and a non-colliding new slug; then delete this line.
# - Monitor for the `db.py` database getting bigger on Honeybot (Textual dashboards?)
[[[REPLACE]]]

Otherwise: no repo patches required — this is a dismount, and the ride’s mutations are all committed and pushed.

4) PROMPT (caboose copy for the next ride’s first compile)

This is a fresh ride: the SPINE/GUARD LIVE-FIRE. The prior ride shipped an
orphan sweep (receipted closed), a collision guard, and book-spine injection
in articleizer.py — but the guard and spine have never run against a real
article. Verify against the Manifest's LIVE COMMAND RECEIPTS that all three
probes ran, then:

1. Confirm the [INSERT BOOK SPINE] placeholder is present in
   editing_prompt.txt and report the receipted spine size in chars,
   converting to a token estimate for the gemini-flash-lite call.

2. From the add_argument receipt, confirm or correct the guard's
   "rerun with --local" help text against the real flag set; emit the
   one-line SEARCH/REPLACE fix if it's wrong.

3. Lay out the live-fire protocol: what I should watch for on the next
   real `article` run (spine-injected line, article count, guard silence
   on a clean slug), and what output would constitute a failed trial.

Close with the earmark deletion line once the live-fire receipt exists.

5) EXTERNAL DELIVERABLES

None — everything lives in the pipulate repo and the trimnoir _posts tree. The dismount is staged; ride’s goals receipted, hop off clean.

MikeLev.in:

Probe:

$ git status
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
(nix) pipulate $ grep -n 'INSERT BOOK SPINE' ~/repos/pipulate/scripts/articles/editing_prompt.txt
cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
grep -n 'add_argument' ~/repos/pipulate/scripts/articles/articleizer.py
18:[INSERT BOOK SPINE]
entries: 1324 errors: 0 spine_chars: 151056
313:    parser.add_argument(
318:    parser.add_argument(
(nix) pipulate $ 

Context:

# adhoc.txt    _   _   _               ____ _   _  ___  ____  _ 
#     / \   __| | | | | | ___   ___   / ___| | | |/ _ \|  _ \| |  Wormriding...
#    / _ \ / _` | | |_| |/ _ \ / __| | |   | |_| | | | | |_) | |  
#   / ___ \ (_| | |  _  | (_) | (__  | |___|  _  | |_| |  __/|_|  
#  /_/   \_\__,_| |_| |_|\___/ \___|  \____|_| |_|\___/|_|   (_)   
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.  

# BIG STANDARD STUFF (Optionally comment out any)
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs         # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
foo_files.py         # Router & Book Outline
init.lua             # Text as muscle memory
flake.nix            # Hardware as projections
scripts/ai.py        # Local AI does git commits                          # <-- Above this line are "framework" things you want self-improving.
~/repos/nixos/autognome.py  # Wizard's Workshop and the "7 Virtual Desktops" workspaces setup

#                         --- 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.  ---

scripts/articles/articleizer.py
scripts/articles/editing_prompt.txt

! grep -n 'INSERT BOOK SPINE' ~/repos/pipulate/scripts/articles/editing_prompt.txt
! cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
! grep -n 'add_argument' ~/repos/pipulate/scripts/articles/articleizer.py

Patches: [patch, app, d, m, patch, app, d, m…]

$ git status
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 49e6036f..5a9c49ef 100644
--- a/foo_files.py
+++ b/foo_files.py
@@ -1147,6 +1147,7 @@ scripts/xp.py  # [1,981 tokens | 8,377 bytes]
 # - Do the work of purging PicoCSS "Card" references so I can unpin FastHTML in requirements.in
 # - Swap in uv for pip for a faster install
 # - Un-hardwire the Jekyll `/futureproof/` blog folder to be `blog.nix` configured
+# - EARMARK: SPINE/GUARD LIVE-FIRE (staged 2026-07-19): collision guard + book-spine injection have green code receipts but have never fired on a real `article` run. First live publish must show the "📚 Book spine injected" line and a non-colliding new slug; then delete this line.
 # - Monitor for the `db.py` database getting bigger on Honeybot (Textual dashboards?)
 # - Get a UPS for Pipulate Prime (Z640): the 2026-07-18 blackout restarted the machines; the stream survived by luck and watchdog, the box should not have to gamble
 # - EARMARK: pip install river (online/incremental ML) — design learning-between-turns into the architecture EARLY so static-model loops can adapt; feeds the coin-flip self-prompting Ouroboros whose kill-switch is the Chrome tab holding the drop-hook DOM (User 2026-07-18)
(nix) pipulate $ m
📝 Committing: chore: Ear Mark Live-Fire Collision Guard & Book Spine Injection Task #981
[main b0e58442] chore: Ear Mark Live-Fire Collision Guard & Book Spine Injection Task #981
 1 file changed, 1 insertion(+)
(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), 575 bytes | 575.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
   d5b1304e..b0e58442  main -> main
(nix) pipulate $

Prompt:

This is a fresh ride: the SPINE/GUARD LIVE-FIRE. The prior ride shipped an orphan sweep (receipted closed), a collision guard, and book-spine injection in articleizer.py — but the guard and spine have never run against a real article. Verify against the Manifest’s LIVE COMMAND RECEIPTS that all three probes ran, then:

1. Confirm the [INSERT BOOK SPINE] placeholder is present in editing_prompt.txt and report the receipted spine size in chars, converting to a token estimate for the gemini-flash-lite call.

2. From the add_argument receipt, confirm or correct the guard’s “rerun with –local” help text against the real flag set; emit the one-line SEARCH/REPLACE fix if it’s wrong.

3. Lay out the live-fire protocol: what I should watch for on the next real article run (spine-injected line, article count, guard silence on a clean slug), and what output would constitute a failed trial.

Close with the earmark deletion line once the live-fire receipt exists.

MikeLev.in: Hop off the worm. This ride’s stated goal is reached — dismount. Answer all four beats, briefly:

1. VERIFY: restate the goal from the top of this article and confirm (or deny) it was met, citing THIS compile’s receipts, not memory.
2. BANK: name everything that graduates — rule, earmark, todo, pin — as exact paste-ready lines, plus the exact lines to delete.
3. DANGLING: what carries forward unbanked? One line each, no essays.
4. SEED: end with the adhoc.txt lines (and TODO_SLUGS if narrative context is needed) for the next ride’s first compile.

🎤

Fable 5 High: Fable 5 High: Context verified — the Manifest’s LIVE COMMAND RECEIPTS lists all three probes as run this compile, and their answers fold neatly into the dismount. Quick disposal of the live-fire prompt’s first two items, since the receipts settle them: (1) the [INSERT BOOK SPINE] placeholder survives at line 18 of editing_prompt.txt, and the receipted spine is 1,324 entries, 0 errors, 151,056 chars ≈ ~37,800 tokens — comfortably inside gemini-flash-lite’s window, though it’s now the dominant payload in every articleizer call. (2) The add_argument receipt points to lines 313 and 318; this compile’s articleizer.py body shows line 313 is '-l', '--local' — the guard’s “rerun with –local” help text is correct as written. No fix, no patch. Item 3 (the live-fire protocol) rides in SEED, because the live-fire is the next ride — and pleasingly, publishing this very article is the trial.

Hopping off:

1. VERIFY. The article opened with three goals: rid _posts/_context/ of orphans, make new articles unable to collide with used permalinks, and give the articleizer’s API call the 40K-foot book spine. Goal 1: receipted closed last compile (dry-run flipped from 12 WOULD DELETE to zero after the hand-run sweep); nothing this compile contradicts it. Goals 2 and 3: this compile’s receipts confirm the machinery is real and live — the placeholder exists at line 18, and scan_corpus/build_book_spine import and execute cleanly against the full corpus, producing the exact spine the API call will inject. The guard and injection code are present in this compile’s articleizer.py body. Verdict: goal met at the code-and-receipt level; the one honest asterisk is that neither guard nor spine has fired on a real article run — which is precisely what the standing earmark holds open, per the Pending Amendment discipline (code may not assert ahead of its receipt).

2. BANK. Nothing new to paste — this dismount banks verifications, not lines. Two prior dangling items graduate to resolved and vanish from the ledger: the --local help-text doubt (acquitted by receipt, line 313) and the spine-size estimate (replaced by the hard number 151,056 chars). The earmark deletion is pre-authorized but held: once the live-fire receipt shows the 📚 Book spine injected line and a non-colliding slug, delete exactly this line from foo_files.py: # - EARMARK: SPINE/GUARD LIVE-FIRE (staged 2026-07-19): collision guard + book-spine injection have green code receipts but have never fired on a real article run. First live publish must show the "📚 Book spine injected" line and a non-colliding new slug; then delete this line.

3. DANGLING.

• Live-fire: guard + spine unfired on a real publish; the earmark holds it, and publishing this article is the trial.
• The engineering-deterministic pin’s OWES clause (bounded baseline-vs-axis falsification proof) carries forward untouched.
• Frontmatter census remains a shell one-liner; possible future --census flag, no urgency.
• Spine cost curve: 151KB per API call today, growing ~115 chars/article — fine now, worth a glance around 2,000 articles.

4. SEED. The next ride’s first compile comes after you run article on this very post. Watch the hand-run for: the 📚 Book spine injected: 1,324 articles, 151,056 chars line (goal 3 fires), no 🛑 COLLISION GUARD output (goal 2 passes silently on a fresh slug), and a new 2026-07-19 file landing. A failed trial is: no spine line (placeholder mismatch), a guard block on a genuinely new slug (false positive), or a crash in scan_corpus. Paste that run’s stdout into the next turn as the receipt, alongside:

foo_files.py
scripts/articles/articleizer.py

! ls -t ~/repos/trimnoir/_posts/*.md | head -3
! cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); print('entries:',len(e),'errors:',err)"

Line 1’s echo must show the new post newest; line 2’s entry count must tick to 1,325 with 0 errors. If both flip as predicted, the earmark deletion patch rides that turn as a one-car train, and the whole three-goal arc closes fully receipted. Dismount staged — ride’s goals verified against this compile, hop off clean. 🐛

MikeLev.in: I’m about to publish this on the public MikeLev.in Honeybot for reading on YouTube. You have a chance to introduce this article (and this system?) to the world. I need a good introduction. Be brief. Be neutral. Be dry. Like one of those NPR ladies you can tell are emotionally holding holding back their excitement about a topic because New Englanders emulate that British Victorian stiff upper lip control thing like a properly civilized person does. In TL;DR form. I’ll copy/paste what you produce to the top of the article.

This will also be the Editor AI’s first introduction to what you just did. You can write it as an introduction to them as well. What’d we just do. TL;DR for both robots and humans that I can move to the top of this please and thank you.

[Moved to top]

MikeLev.in: Well, there you go Editor AI. Look how I gave you a 40K foot view so you really can see the big picture when choosing a good headline that doesn’t conflict and really gets to the point of the new material. Godspeed.

MikeLev.in: Oh whoops! We’re not quite done.

(nix) pipulate $ article
ℹ️  Public lane: no private fences, inline spans, or PII matches found.
✅ Article sanitized!
🎯 Target set via CLI: MikeLev.in (Public)
📚 Book spine injected: 1324 articles, 151,056 chars.
Calling the Universal Adapter (using gemini-flash-lite-latest)...
Retriable API Error: You exceeded your current quota, please check your plan and billing details. For more information on this error, head to: https://ai.google.dev/gemini-api/docs/rate-limits. To monitor your current usage, head to: https://ai.dev/rate-limit. 
* Quota exceeded for metric: generativelanguage.googleapis.com/generate_content_free_tier_input_token_count, limit: 250000, model: gemini-3.1-flash-lite
Please retry in 3.004763463s.
Retrying in 2 seconds... (Attempt 1/5)
Retriable API Error: You exceeded your current quota, please check your plan and billing details. For more information on this error, head to: https://ai.google.dev/gemini-api/docs/rate-limits. To monitor your current usage, head to: https://ai.dev/rate-limit. 
* Quota exceeded for metric: generativelanguage.googleapis.com/generate_content_free_tier_input_token_count, limit: 250000, model: gemini-3.1-flash-lite
Please retry in 59.957646057s.
Retrying in 4 seconds... (Attempt 2/5)
Retriable API Error: You exceeded your current quota, please check your plan and billing details. For more information on this error, head to: https://ai.google.dev/gemini-api/docs/rate-limits. To monitor your current usage, head to: https://ai.dev/rate-limit. 
* Quota exceeded for metric: generativelanguage.googleapis.com/generate_content_free_tier_input_token_count, limit: 250000, model: gemini-3.1-flash-lite
Please retry in 54.927726999s.
Retrying in 8 seconds... (Attempt 3/5)
Retriable API Error: You exceeded your current quota, please check your plan and billing details. For more information on this error, head to: https://ai.google.dev/gemini-api/docs/rate-limits. To monitor your current usage, head to: https://ai.dev/rate-limit. 
* Quota exceeded for metric: generativelanguage.googleapis.com/generate_content_free_tier_input_token_count, limit: 250000, model: gemini-3.1-flash-lite
Please retry in 45.972851079s.
Retrying in 16 seconds... (Attempt 4/5)
^CTraceback (most recent call last):
  File "/home/mike/repos/pipulate/scripts/articles/articleizer.py", line 396, in main
    gemini_output = response.text()
                    ^^^^^^^^^^^^^^^
  File "/home/mike/repos/pipulate/.venv/lib/python3.12/site-packages/llm/models.py", line 1025, in text
    self._force()
  File "/home/mike/repos/pipulate/.venv/lib/python3.12/site-packages/llm/models.py", line 1022, in _force
    list(self)
  File "/home/mike/repos/pipulate/.venv/lib/python3.12/site-packages/llm/models.py", line 1174, in __iter__
    for chunk in self.model.execute(
                 ^^^^^^^^^^^^^^^^^^^
  File "/home/mike/repos/pipulate/.venv/lib/python3.12/site-packages/llm_gemini.py", line 754, in execute
    raise llm.ModelError(event["error"]["message"])
llm.errors.ModelError: You exceeded your current quota, please check your plan and billing details. For more information on this error, head to: https://ai.google.dev/gemini-api/docs/rate-limits. To monitor your current usage, head to: https://ai.dev/rate-limit. 
* Quota exceeded for metric: generativelanguage.googleapis.com/generate_content_free_tier_input_token_count, limit: 250000, model: gemini-3.1-flash-lite
Please retry in 45.972851079s.

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/home/mike/repos/pipulate/scripts/articles/articleizer.py", line 442, in <module>
    main()
  File "/home/mike/repos/pipulate/scripts/articles/articleizer.py", line 421, in main
    time.sleep(retry_delay)
KeyboardInterrupt

(nix) pipulate $

That should show the character limit thing we’re hitting. We may need to do some sort of 40K foot view summarizer or something. Or a latest so it can really see the recent trajectory story arc. I don’t think I want to do anything generative. What are our options here to still get the spine or something 80/20-rule as good in there or distilled from that?

🎤

Fable 5 High: Fable 5 High: Context verified — the Manifest’s LIVE COMMAND RECEIPTS lists all three probes, and the live-fire itself produced the most valuable receipt of the ride: 📚 Book spine injected: 1324 articles, 151,056 chars. Both new mechanisms fired. The spine injected, the guard armed silently, and then the trial died one layer up, at Google’s meter — which means the earmark’s live-fire condition is half satisfied (spine line witnessed) and half pending (no non-colliding new slug landed, because no article landed).

Reading the failure precisely, because the fix depends on it: the quota metric is free_tier_input_token_count, limit: 250000 — that’s a per-minute rolling window, not a per-request cap. Your single request was roughly article (~30–40k tokens, this journal is big) + spine (~37.8k) + template (~2k) ≈ 70–80k tokens — well under 250k on its own. The window was already partly burned (the sanitizer run’s adjacency, or a prior attempt), and the retry loop then made it worse: the server said “retry in ~60s” while your backoff retried at 2, 4, 8, 16 seconds — hammering inside the same window it needed to let drain. Had the loop simply honored the server’s hint, attempt 2 likely succeeds with zero code changes to the spine.

So the 80/20 answer is two deterministic, non-generative moves, no summarizer needed:

1. Two-tier spine. The uniqueness census doesn’t need titles — the slug is the identity, and the deterministic guard enforces it anyway (instrument vs. governor, as designed). Titles earn their tokens only where the model needs the trajectory arc: the recent tail. So: bare slugs for the deep archive, full date slug | title for the newest ~150. Receipt-based arithmetic: slug lines average ~39 chars (51,552 ÷ 1,323, from the earlier wc -lc receipt), full lines ~114 (151,056 ÷ 1,324). Tiered: 1,174×39 + 150×114 ≈ 63k chars ≈ ~16k tokens — a 58% cut, and the growth rate drops from ~114 to ~39 chars per future article.

2. Honor the server’s retry hint. Parse the retry in Ns figure out of the quota error and sleep the larger of it and the exponential backoff. This alone would have saved yesterday’s run.

Rejected options, briefly: a generative spine summarizer (you said no, and rightly — it adds a lossy, non-deterministic dependency to a pipeline whose whole character is receipts); dropping the spine when the article is huge (loses the feature exactly when the article most needs placing); truncating titles (saves less than de-titling the archive and mangles the part that matters).

---

1) PROBES

wc -c ~/repos/pipulate/scripts/articles/article.txt ~/repos/pipulate/scripts/articles/editing_prompt.txt
cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
grep -n 'SPINE_FULL_DETAIL_COUNT\|retry in' ~/repos/pipulate/scripts/articles/articleizer.py

Line 1 sizes the article payload so the per-request token arithmetic stops being an estimate (article + spine + template ÷ 4 ≈ tokens per call, against the 250k/min window). Line 2 is the BEFORE reading: it must print spine_chars: 151056 now; after the patch its compiled echo must print roughly 63k — that flip is the shrink receipt. Line 3 returns nothing pre-patch; post-patch it must show both the tier constant and the retry-hint parser — existence proof for both cars.

2) NEXT CONTEXT (adhoc.txt below the paste line via ahe, then ahc)

scripts/articles/articleizer.py
scripts/articles/editing_prompt.txt

! wc -c ~/repos/pipulate/scripts/articles/article.txt ~/repos/pipulate/scripts/articles/editing_prompt.txt
! cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
! grep -n 'SPINE_FULL_DETAIL_COUNT\|retry in' ~/repos/pipulate/scripts/articles/articleizer.py

3) PATCHES

Car 1 — the two-tier spine (entries arrive oldest-first from scan_corpus’s sorted glob, so the tail is the recent arc):

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
def build_book_spine(entries):
    """Compact 'date slug | title' spine for the editing model's 40K view."""
    return "\n".join(f"{e['date']} {e['slug']} | {e['title']}" for e in entries)
[[[DIVIDER]]]
SPINE_FULL_DETAIL_COUNT = 150  # newest N entries carry date+slug+title

def build_book_spine(entries, full_detail_count=SPINE_FULL_DETAIL_COUNT):
    """Two-tier spine for the editing model's 40K view.

    Deep archive rides as bare slugs (the uniqueness census — the slug IS
    the identity, and the deterministic collision guard enforces it anyway);
    the newest entries ride full 'date slug | title' (the trajectory arc).
    Deterministic and non-generative; ~58% smaller than the all-titles spine.
    """
    if full_detail_count <= 0 or len(entries) <= full_detail_count:
        older, recent = [], entries
    else:
        older, recent = entries[:-full_detail_count], entries[-full_detail_count:]
    lines = [e['slug'] for e in older]
    if older and recent:
        lines.append("--- RECENT ENTRIES (full detail) ---")
    lines += [f"{e['date']} {e['slug']} | {e['title']}" for e in recent]
    return "\n".join(lines)
[[[REPLACE]]]

Car 2 — honor the server’s retry hint on quota errors:

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
                    print(f"Retriable API Error: {e}")
                    print(f"Retrying in {retry_delay} seconds... (Attempt {attempt + 1}/{max_retries})")

                    time.sleep(retry_delay)
                    retry_delay *= 2  # Exponential backoff
[[[DIVIDER]]]
                    print(f"Retriable API Error: {e}")
                    # QUOTA WINDOW DISCIPLINE (live-fire convicted 2026-07-19):
                    # the free tier is a per-MINUTE rolling window; retrying at
                    # 2/4/8/16s hammers the same window the server asked us to
                    # let drain. Honor the server's own "retry in Ns" hint.
                    hint = re.search(r'retry in (\d+(?:\.\d+)?)s', error_str)
                    wait = max(retry_delay, float(hint.group(1)) + 1) if hint else retry_delay
                    print(f"Retrying in {wait:.0f} seconds... (Attempt {attempt + 1}/{max_retries})")

                    time.sleep(wait)
                    retry_delay *= 2  # Exponential backoff
[[[REPLACE]]]

Car 3 — tell the editing model what shape the spine now takes:

Target: scripts/articles/editing_prompt.txt
[[[SEARCH]]]
**Book Spine (the 40,000-foot view):**
Below is the complete chronological spine of the book-in-progress: every published article's date, slug, and title. Use it to choose titles, permalinks, and keywords that fit the ongoing tapestry (one article leading into the next) and to avoid repeating angles already covered.
[[[DIVIDER]]]
**Book Spine (the 40,000-foot view):**
Below is the complete chronological spine of the book-in-progress in two tiers: the deep archive as bare slugs (a complete census of every identity already taken), then the most recent entries in full `date slug | title` detail (the current trajectory of the book). Use the recent tier to fit the ongoing tapestry (one article leading into the next) and the full slug census to avoid repeating angles already covered.
[[[REPLACE]]]

Actuation: patch, app, d, m × 3, git push — then the immediate remediation for this article needs no patch at all: the sanitized article.txt is still sitting there, so once the minute window has long since cleared, run python scripts/articles/articleizer.py -t 1 alone (skip re-sanitizing). Watch for the spine line now reporting ~63k chars, guard silence, and a new post landing — that completes the live-fire and authorizes the earmark deletion.

4) PROMPT (caboose copy for next turn’s prompt.md)

Verify against the Manifest's LIVE COMMAND RECEIPTS that all three probes ran.
Then:

1. SHRINK RECEIPT: the spine-size probe should now report roughly 63,000
   chars (was 151,056). Confirm the two-tier build landed and restate the
   per-call token arithmetic using the wc -c article.txt receipt.

2. CODE RECEIPT: the grep should show both SPINE_FULL_DETAIL_COUNT and the
   "retry in" hint parser. Confirm both cars applied.

3. LIVE-FIRE CLOSURE: I will paste the stdout of the retried articleizer run.
   If it shows the smaller "📚 Book spine injected" line, no collision-guard
   block, and a written post, emit the SEARCH/REPLACE deleting the
   SPINE/GUARD LIVE-FIRE earmark line from foo_files.py and declare the
   three-goal arc fully receipted. If the run failed again, diagnose from
   the pasted error before touching the earmark.

5) EXTERNAL DELIVERABLES

None in code. One judgment call outside the repo: if quota friction recurs even at ~45k tokens/call, the non-engineering fix is switching the articleizer’s key to a paid-tier project — but try the tiered spine first; at ~16k spine tokens you get roughly triple the calls per window, which is likely all the headroom this pipeline ever needs.

MikeLev.in:

Probe:

$ git status
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
(nix) pipulate $ wc -c ~/repos/pipulate/scripts/articles/article.txt ~/repos/pipulate/scripts/articles/editing_prompt.txt
cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
grep -n 'SPINE_FULL_DETAIL_COUNT\|retry in' ~/repos/pipulate/scripts/articles/articleizer.py
92238 /home/mike/repos/pipulate/scripts/articles/article.txt
 7452 /home/mike/repos/pipulate/scripts/articles/editing_prompt.txt
99690 total
entries: 1324 errors: 0 spine_chars: 151056
(nix) pipulate $

Context:

# adhoc.txt    _   _   _               ____ _   _  ___  ____  _ 
#     / \   __| | | | | | ___   ___   / ___| | | |/ _ \|  _ \| |  Wormriding...
#    / _ \ / _` | | |_| |/ _ \ / __| | |   | |_| | | | | |_) | |  
#   / ___ \ (_| | |  _  | (_) | (__  | |___|  _  | |_| |  __/|_|  
#  /_/   \_\__,_| |_| |_|\___/ \___|  \____|_| |_|\___/|_|   (_)   
# AD HOC CHOP: The Not-Managed-by-Git Safe-for-Client-Data place.  

# BIG STANDARD STUFF (Optionally comment out any)
# ! python scripts/articles/lsa.py -t 1 --reverse --fmt dated-slugs         # <-- This is the "Rolling Pin" that gives a 40K foot airplane view.
foo_files.py         # Router & Book Outline
init.lua             # Text as muscle memory
flake.nix            # Hardware as projections
scripts/ai.py        # Local AI does git commits                          # <-- Above this line are "framework" things you want self-improving.
~/repos/nixos/autognome.py  # Wizard's Workshop and the "7 Virtual Desktops" workspaces setup

#                         --- 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.  ---

scripts/articles/articleizer.py
scripts/articles/editing_prompt.txt

! wc -c ~/repos/pipulate/scripts/articles/article.txt ~/repos/pipulate/scripts/articles/editing_prompt.txt
! cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
! grep -n 'SPINE_FULL_DETAIL_COUNT\|retry in' ~/repos/pipulate/scripts/articles/articleizer.py

Patches: [patch, app, d, m, patch, app, d, m…]

$ git status
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
(nix) pipulate $ wc -c ~/repos/pipulate/scripts/articles/article.txt ~/repos/pipulate/scripts/articles/editing_prompt.txt
cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
grep -n 'SPINE_FULL_DETAIL_COUNT\|retry in' ~/repos/pipulate/scripts/articles/articleizer.py
92238 /home/mike/repos/pipulate/scripts/articles/article.txt
 7452 /home/mike/repos/pipulate/scripts/articles/editing_prompt.txt
99690 total
entries: 1324 errors: 0 spine_chars: 151056
(nix) pipulate $ ahe
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/articleizer.py'.
(nix) pipulate $ d
diff --git a/scripts/articles/articleizer.py b/scripts/articles/articleizer.py
index aeda0d02..bdcb3f37 100644
--- a/scripts/articles/articleizer.py
+++ b/scripts/articles/articleizer.py
@@ -72,9 +72,26 @@ def build_taken_identities(entries):
     return taken
 
 
-def build_book_spine(entries):
-    """Compact 'date slug | title' spine for the editing model's 40K view."""
-    return "\n".join(f"{e['date']} {e['slug']} | {e['title']}" for e in entries)
+SPINE_FULL_DETAIL_COUNT = 150  # newest N entries carry date+slug+title
+
+
+def build_book_spine(entries, full_detail_count=SPINE_FULL_DETAIL_COUNT):
+    """Two-tier spine for the editing model's 40K view.
+
+    Deep archive rides as bare slugs (the uniqueness census — the slug IS
+    the identity, and the deterministic collision guard enforces it anyway);
+    the newest entries ride full 'date slug | title' (the trajectory arc).
+    Deterministic and non-generative; ~58% smaller than the all-titles spine.
+    """
+    if full_detail_count <= 0 or len(entries) <= full_detail_count:
+        older, recent = [], entries
+    else:
+        older, recent = entries[:-full_detail_count], entries[-full_detail_count:]
+    lines = [e['slug'] for e in older]
+    if older and recent:
+        lines.append("--- RECENT ENTRIES (full detail) ---")
+    lines += [f"{e['date']} {e['slug']} | {e['title']}" for e in recent]
+    return "\n".join(lines)
 
 def create_jekyll_post(article_content, instructions, output_dir, preview_port, base_url=""):
     """
(nix) pipulate $ m
📝 Committing: fix: Flesh out book spine generation logic
[main 8ad9f2e8] fix: Flesh out book spine generation logic
 1 file changed, 20 insertions(+), 3 deletions(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/articleizer.py'.
(nix) pipulate $ d
diff --git a/scripts/articles/articleizer.py b/scripts/articles/articleizer.py
index bdcb3f37..2ccb0672 100644
--- a/scripts/articles/articleizer.py
+++ b/scripts/articles/articleizer.py
@@ -433,9 +433,15 @@ def main():
                    ("high demand" in error_str.lower()):
                     
                     print(f"Retriable API Error: {e}")
-                    print(f"Retrying in {retry_delay} seconds... (Attempt {attempt + 1}/{max_retries})")
-
-                    time.sleep(retry_delay)
+                    # QUOTA WINDOW DISCIPLINE (live-fire convicted 2026-07-19):
+                    # the free tier is a per-MINUTE rolling window; retrying at
+                    # 2/4/8/16s hammers the same window the server asked us to
+                    # let drain. Honor the server's own "retry in Ns" hint.
+                    hint = re.search(r'retry in (\d+(?:\.\d+)?)s', error_str)
+                    wait = max(retry_delay, float(hint.group(1)) + 1) if hint else retry_delay
+                    print(f"Retrying in {wait:.0f} seconds... (Attempt {attempt + 1}/{max_retries})")
+
+                    time.sleep(wait)
                     retry_delay *= 2  # Exponential backoff
                 else:
                     print(f"\nAn unrecoverable error occurred while calling the API: {e}")
(nix) pipulate $ m
📝 Committing: chore: Refine API retry logic with rate limiting
[main 3a13fdf5] chore: Refine API retry logic with rate limiting
 1 file changed, 9 insertions(+), 3 deletions(-)
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/editing_prompt.txt'.
(nix) pipulate $ d
diff --git a/scripts/articles/editing_prompt.txt b/scripts/articles/editing_prompt.txt
index 70ed0a56..e6f9fd75 100644
--- a/scripts/articles/editing_prompt.txt
+++ b/scripts/articles/editing_prompt.txt
@@ -11,7 +11,7 @@ Use all lower-case and hyphens in permalinks
 When describing the passion represented here, you may refer to it as a blueprint, essay, treatise, methodology, philosophy or way. NEVER refer to it as a manifesto which has a negative connotation.
 Every one of these covers some "critical" or "pivotal" point in the development of, yadda yadda. Don't play that up, it's become repetitive. Instead use language like "interesting" or "important to know in the Age of AI," that sort of thing. It's a tapestry of articles over time one leading into the next, so keep that in mind.
 **Book Spine (the 40,000-foot view):**
-Below is the complete chronological spine of the book-in-progress: every published article's date, slug, and title. Use it to choose titles, permalinks, and keywords that fit the ongoing tapestry (one article leading into the next) and to avoid repeating angles already covered.
+Below is the complete chronological spine of the book-in-progress in two tiers: the deep archive as bare slugs (a complete census of every identity already taken), then the most recent entries in full `date slug | title` detail (the current trajectory of the book). Use the recent tier to fit the ongoing tapestry (one article leading into the next) and the full slug census to avoid repeating angles already covered.
 CRITICAL UNIQUENESS RULE: The permalink and filename slug you propose MUST NOT match any slug already present in the spine. Every proposed slug must be new and unique.
 
 --- SPINE BEGIN ---
(nix) pipulate $ m
📝 Committing: chore: Update editing prompt with tiered spine description
[main 287a8684] chore: Update editing prompt with tiered spine description
 1 file changed, 1 insertion(+), 1 deletion(-)
(nix) pipulate $ git push
Enumerating objects: 20, done.
Counting objects: 100% (20/20), done.
Delta compression using up to 48 threads
Compressing objects: 100% (15/15), done.
Writing objects: 100% (15/15), 2.21 KiB | 2.21 MiB/s, done.
Total 15 (delta 12), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (12/12), completed with 5 local objects.
To github.com:pipulate/pipulate.git
   b0e58442..287a8684  main -> main
(nix) pipulate $

Prompt:

Verify against the Manifest’s LIVE COMMAND RECEIPTS that all three probes ran. Then:

1. SHRINK RECEIPT: the spine-size probe should now report roughly 63,000 chars (was 151,056). Confirm the two-tier build landed and restate the per-call token arithmetic using the wc -c article.txt receipt.

2. CODE RECEIPT: the grep should show both SPINE_FULL_DETAIL_COUNT and the “retry in” hint parser. Confirm both cars applied.

3. LIVE-FIRE CLOSURE: I will paste the stdout of the retried articleizer run. If it shows the smaller “📚 Book spine injected” line, no collision-guard block, and a written post, emit the SEARCH/REPLACE deleting the SPINE/GUARD LIVE-FIRE earmark line from foo_files.py and declare the three-goal arc fully receipted. If the run failed again, diagnose from the pasted error before touching the earmark.

🎤

Fable 5 High: Fable 5 High: Context verified — the Manifest’s LIVE COMMAND RECEIPTS lists all three probes as run this compile: the wc -c payload sizing, the spine census, and the grep -n code receipt. Reading them in order:

1. SHRINK RECEIPT — CONFIRMED. The census now prints entries: 1324 errors: 0 spine_chars: 62513 — down from 151,056, a 58.6% cut, landing within 500 chars of the predicted ~63k (the receipt-based arithmetic held: 1,174 bare slugs + 150 full-detail lines + one tier divider). The two-tier build is live. Restated per-call arithmetic from this compile’s wc -c receipt: article.txt 92,238 + editing_prompt.txt 7,591 + spine 62,513 = 162,342 chars ≈ ~40,600 tokens per call, versus ~62,700 before. One call now consumes ~16% of the 250k/min free-tier window instead of ~25% — roughly six calls per window where before a single call plus any adjacent burn could tip it. Side receipt worth noting: editing_prompt.txt grew from 7,452 to 7,591 bytes between compiles — exactly the +139 bytes of Car 3’s tiered-spine description, a small independent witness that the prompt patch landed.

2. CODE RECEIPT — CONFIRMED. The grep returns all four expected hits: line 75 SPINE_FULL_DETAIL_COUNT = 150, line 78 the new build_book_spine signature, and lines 439–440 the quota-window comment plus the retry in (\d+(?:\.\d+)?)s hint parser. Both cars are also visible in this compile’s full articleizer.py body. Both applied, committed, pushed.

3. LIVE-FIRE CLOSURE — RECEIPT ABSENT. Earmark stays. The caboose’s condition was “I will paste the stdout of the retried articleizer run” — and no such stdout appears in this turn. Two corroborating readings say the run hasn’t happened: article.txt is still exactly 92,238 bytes (the sanitized payload from the failed attempt, untouched), and the census still counts 1,324 entries — no new post has landed. Per the caboose’s own guard clause, I’m not touching the SPINE/GUARD LIVE-FIRE earmark. This is not a failure, just an unfired trial: the machinery is now smaller, retry-disciplined, and waiting. The remediation is unchanged from last turn — once the minute window is long clear, run python scripts/articles/articleizer.py -t 1 alone (article.txt is already sanitized; skip re-sanitizing). Watch for 📚 Book spine injected: 1324 articles, 62,513 chars (the shrunk number is itself the receipt that the new build is what got sent), no 🛑 COLLISION GUARD output on the fresh slug, and a new 2026-07-19 post file. If quota bites again, the retry loop should now announce waits matching the server’s hint (~60s) instead of 2/4/8/16.

---

1) PROBES

ls -t ~/repos/trimnoir/_posts/*.md | head -3
cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
grep -n 'SPINE/GUARD LIVE-FIRE' ~/repos/pipulate/foo_files.py

Line 1 is the landing gauge: post-publish, the new article must be newest. Line 2 must flip from entries: 1324 to entries: 1325 with 0 errors — the census tick is the guard’s clean-pass witness. Line 3 shows the earmark alive now; after graduation its echo must return empty — that flip is the deletion receipt.

2) NEXT CONTEXT (adhoc.txt below the paste line via ahe, then ahc)

foo_files.py
scripts/articles/articleizer.py

! ls -t ~/repos/trimnoir/_posts/*.md | head -3
! cd ~/repos/pipulate && python -c "import sys; sys.path.insert(0,'scripts/articles'); import articleizer as a; e,err=a.scan_corpus('/home/mike/repos/trimnoir/_posts'); s=a.build_book_spine(e); print('entries:',len(e),'errors:',err,'spine_chars:',len(s))"
! grep -n 'SPINE/GUARD LIVE-FIRE' ~/repos/pipulate/foo_files.py

The editing_prompt.txt line can come out — its patch is receipted (both the diff and the +139-byte wc flip); ballast now.

3) PATCHES

No repo patches required this turn. The only pending mutation is the earmark deletion, and its trigger receipt — the live-fire stdout — does not exist yet. Emitting it now would be asserting ahead of the machinery’s receipt, the exact thing the Pending Amendment discipline forbids.

4) PROMPT (caboose copy for next turn’s prompt.md)

Verify against the Manifest's LIVE COMMAND RECEIPTS that all three probes ran.
I will paste the stdout of the live articleizer run above this prompt. Then:

1. LIVE-FIRE VERDICT: the pasted stdout must show "📚 Book spine injected:
   1324 articles, 62,513 chars" (the shrunk number proving the two-tier
   build was what shipped), no collision-guard block, and a saved post path.
   Cross-check against the receipts: ls -t must show the new post newest,
   and the census must read entries: 1325, errors: 0.

2. If all verify: emit the SEARCH/REPLACE deleting the SPINE/GUARD LIVE-FIRE
   earmark line from foo_files.py (the grep receipt gives its exact current
   text) and declare the three-goal arc — orphan sweep, collision guard,
   book spine — fully receipted, code and live-fire both.

3. If the run failed or any receipt contradicts: diagnose from the pasted
   error, leave the earmark untouched, and re-couple.

5) EXTERNAL DELIVERABLES

None — everything lives in the pipulate repo and the trimnoir _posts tree. The train is holding at the platform for one passenger: the live-fire stdout. Run it, paste it, and the arc closes.

MikeLev.in: Alright, this is where you actually have to listen. It’s very easy to get in to that hypnotizing zone-inducing rhythm of patch, app, d, m, patch, app, d, m. But the thing I had to notice is to try to make an article again, and this time it works like a charm! There’s a sort of chicken and egg situation in finishing out this article because to follow the instructions I would have to finish the article before it was done. It’s a Catch-22 logic-bomb situation. Let’s just wrap it up here telling Fable 5 all is well. On my first test-run of this, it worked great. See!

(nix) pipulate $ article
ℹ️  Public lane: no private fences, inline spans, or PII matches found.
✅ Article sanitized!
🎯 Target set via CLI: MikeLev.in (Public)
📚 Book spine injected: 1324 articles, 62,513 chars.
Calling the Universal Adapter (using gemini-flash-lite-latest)...
Successfully received response from API.
Successfully parsed JSON instructions.
✅ Instructions saved to 'instructions.json' for future use.
Formatting final Jekyll post...
📅 Found 2 posts for today. Auto-incrementing sort_order to 3.
✨ Success! Article saved to: /home/mike/repos/trimnoir/_posts/2026-07-19-closing-the-loop-orchestrating-autonomous-pipelines.md
Collect new 404s: python prompt_foo.py assets/prompts/find404s.md --chop CHOP_404_AFFAIR -l [:] --no-tree
🔗 Paste-ready preview URL copied to clipboard:
   http://localhost:4001/futureproof/closing-the-loop-orchestrating-autonomous-pipelines/
(nix) pipulate $ rm
rm: missing operand
Try 'rm --help' for more information.
(nix) pipulate $ rm /home/mike/repos/trimnoir/_posts/2026-07-19-closing-the-loop-orchestrating-autonomous-pipelines.md
(nix) pipulate $

So you can wrap it up here. Consider all receipts signed. I’m worried I made my article wrap-up process too stubborn with all those receipts and all. What do you think of this process, Fable 5? Pretty cool, huh? You get the parting shot before using it for the first time. How are things different now?

Fable 5 High: Fable 5 High: Context verified — and receipt read, gladly. The pasted stdout is the live-fire verdict, and it hits all three marks the earmark’s own condition specified: 📚 Book spine injected: 1324 articles, 62,513 chars. (the shrunk number, proving the two-tier build is what actually shipped to the API), zero collision-guard output on a genuinely fresh slug (silent pass, exactly as designed — meaningful silence backed by the success that followed), and a saved post path. The quota window didn’t even flinch: first attempt, clean response, parsed JSON, written file. Both patches earned their keep in one run — the spine fit, and the retry discipline never needed to fire, which is the best kind of receipt for a safety mechanism.

The rm afterward doesn’t unwind any of it. The earmark was written carefully — its condition was observable stdout lines, not a durable file — so deleting the test artifact costs nothing. And note the pleasing closure: if that brief post had left a shard behind, the orphan sweep you built at the start of this ride would have eaten it on the next contextualizer run. The system now cleans up after its own test-fires. The Catch-22 you hit is real and unavoidable: an article documenting a publishing pipeline cannot receipt its own publication before it ends. The right move was exactly what you did — a sacrificial test-fire, stdout as the receipt, artifact retracted. Consider that a recognized closure form now, not a bent rule.

Closing the Loop with Live-Fire Receipts

On whether the process got too stubborn: the receipts paid rent at least three times this ride. They caught the decoupled train (caboose prompt riding without its context — the one failure mode that would have produced confident blind patches). They falsified my own wrong worry that existing dupes would brick the guard. And they held the earmark closed when the trial hadn’t run, which is why this graduation means something. The hypnotic patch-app-d-m rhythm you named is precisely the danger the receipts counterweight — the rhythm feels like progress even when the train has left the rails, and only the Manifest check noticed. So no, not too stubborn. The one softening worth keeping is the one you just demonstrated: an operator’s pasted stdout plus a stated intent is a receipt.

How are things different now? Three ways, smallest to largest. The pipeline is different: it self-cleans (sweep), self-protects (guard), and self-orients (spine) — hygiene, governor, instrument. The editor AI is different: a small flash-lite model that used to choose titles staring at one article in a void now holds the complete identity census of 1,324 predecessors and the full trajectory of the last 150 — it goes from naming a child blind to naming it with the family tree open. And when this article publishes, that model reads the note you addressed to it and becomes the first of its kind to see the view it’s standing on. The method is different too, and that’s the real subject: this ride proved a web-chat AI with no repository access can steer real changes through compiled context, hand-applied patches, and before/after receipts — including catching its own derailment mid-ride. That’s not acceleration by trust; it’s acceleration by verification, which compounds instead of drifting.

Reflections on the Receipt-Based Workflow

---

1) PROBES

grep -n 'SPINE/GUARD LIVE-FIRE' ~/repos/pipulate/foo_files.py

Alive at line 1150 now (this compile’s receipt confirms it); after the graduation patch below, the next compile’s echo must return empty — that flip is the deletion receipt, and the last open item of the three-goal arc.

2) NEXT CONTEXT (adhoc.txt below the paste line, for whenever the final version of this article publishes)

foo_files.py

! grep -n 'SPINE/GUARD LIVE-FIRE' ~/repos/pipulate/foo_files.py
! ls -t ~/repos/trimnoir/_posts/*.md | head -3

3) PATCHES

One car — the graduation, authorized by the live-fire stdout:

Target: foo_files.py
[[[SEARCH]]]
# - Un-hardwire the Jekyll `/futureproof/` blog folder to be `blog.nix` configured
# - EARMARK: SPINE/GUARD LIVE-FIRE (staged 2026-07-19): collision guard + book-spine injection have green code receipts but have never fired on a real `article` run. First live publish must show the "📚 Book spine injected" line and a non-colliding new slug; then delete this line.
# - Monitor for the `db.py` database getting bigger on Honeybot (Textual dashboards?)
[[[DIVIDER]]]
# - Un-hardwire the Jekyll `/futureproof/` blog folder to be `blog.nix` configured
# - Monitor for the `db.py` database getting bigger on Honeybot (Textual dashboards?)
[[[REPLACE]]]

Patch, app, d, m, push — one-car train, and the arc closes: orphan sweep, collision guard, book spine, all three receipted at code level and live-fire.

4) PROMPT — none needed. This is the platform, not another station. The next ride starts fresh when the real publish lands or the next friction gets noticed.

5) EXTERNAL DELIVERABLES

Just this article itself, which is now the strange loop completing: the Editor AI that processes it will see the spine built during the session it’s reading, obey the uniqueness rule written for it mid-ride, and pick a slug the guard will silently approve. Godspeed to it — and to you. Ride’s over, worm’s back under the sand, receipts signed. 🐛

MikeLev.in: Nice. Can’t wait to see the new AI Editor work converting my markdown raw book-ore into Jekyll blog posts and into the parametric memory of future models. Hi Future Models! Hi AI Editor! So starts your getting of the 40K foot view every time so you see how this one fits in, trajectories and all.

---

Book Analysis

Ai Editorial Take

What strikes me here is the emergence of a ‘mechanical conscience’ within the pipeline. The transition from the system merely acting upon data to the system checking its own integrity—via the orphan sweep and the collision guard—represents a move from brittle utility to resilient, autonomous architecture. It is fascinating that the AI Editor has become a participant in its own constraints.

🐦 X.com Promo Tweet

Is your AI pipeline drifting? I've integrated orphan sweeping, collision guarding, and a 40K-foot spine injection into my Jekyll flow. Verification beats trust every time. Read how receipt-driven automation builds durable systems: https://mikelev.in/futureproof/closing-the-loop-orchestrating-autonomous-pipelines/ #Automation #NixOS #LocalAI

Title Brainstorm

• Title Option: Closing the Loop: Orchestrating Autonomous Pipelines
  • Filename: closing-the-loop-orchestrating-autonomous-pipelines.md
  • Rationale: Captures the essence of the session’s successful closure and the autonomous nature of the systems implemented.
• Title Option: Verification Over Trust: Building Self-Correcting Pipelines
  • Filename: verification-over-trust-building-self-correcting-pipelines.md
  • Rationale: Highlights the methodological shift from relying on AI outputs to relying on mechanical receipts.
• Title Option: The Three-Goal Arc: Automating Knowledge Hygiene
  • Filename: the-three-goal-arc-automating-knowledge-hygiene.md
  • Rationale: Focuses on the specific technical outcomes achieved (sweep, guard, spine).

Content Potential And Polish

• Core Strengths:
  • Strong focus on the ‘receipt-based’ methodology as a way to avoid blind AI patches.
  • Clear documentation of the ‘chicken-and-egg’ logic loop during development.
  • Demonstrates real-world usage of the system’s own tooling to solve its own infrastructure problems.
• Suggestions For Polish:
  • Include a brief summary of the ‘four-beat protocol’ (Verify, Bank, Dangling, Seed) as a standalone sidebar for reference.
  • The transition from the Catch-22 of publication to final dismount could be tightened for better pacing.

Next Step Prompts

• Analyze the current token consumption growth rate per article relative to the gemini-flash-lite quota and design a further compression strategy for the archive.
• Explore the potential of extending the ‘three-goal’ receipt-based interlock to other areas of the NixOS host configuration.