ALPHABET = "0123456789BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz"

Base52: the ten digits plus both cases of every letter except A, E, I, O, and U. The ordering and the omissions do different jobs.

The conventional vowels are dropped to make ordinary-word collisions rarer. These keys are embedded in model-generated prose and matched back out of it by the harness’s ACK grammar, so reducing the surface shared with English is useful. Fixed width and the surrounding ACK syntax identify the stamp.

The ordering is the other trick. Digits, then uppercase consonants, then lowercase is ASCII-monotonic—the alphabet’s rank order equals byte order—so a fixed-width, zero-padded encoding of epoch microseconds sorts lexicographically in time order under bytewise comparison. Python’s ordinary string order for these ASCII characters, SQLite’s BINARY collation, and LC_ALL=C sort agree on chronology without parsing anything. Locale-aware sorting need not.

Width and unit are one decision. A stamp of $w$ characters counting unit $u$ spans $52^w u$ from the epoch. Each row below adds a character and a thousandfold finer unit, keeping about a nineteenth of the span above it:

$$\begin{aligned} 52^{8}\,\text{ms} &\approx 1694\ \text{years} \\ 52^{9}\,\text{µs} &\approx 88.1\ \text{years} \\ 52^{10}\,\text{ns} &\approx 4.58\ \text{years} \end{aligned}$$

The first character turns once per fifty-second of the span: every 32.6 years, 1.69 years, and 32 days. Eight characters of milliseconds reach 3664, and their first character reads 1 from 2002 to 2035. Ten characters of nanoseconds ran out in 1974. Nanoseconds need eleven characters, and Python’s datetime stops at microseconds. Ten characters of microseconds are the same nine behind a 0 until 2058.

Nine characters of microseconds reach February 2058. Their first character reads d from November 2025 to August 2027, and each character after it turns 52 times as often: about every 12 days, 5.5 hours, 6.3 minutes, 7.3 seconds, 141 ms, 2.7 ms, 52 µs, and 1 µs. A shared prefix is a shared span: stamps that agree on two characters were minted in the same 12 days, on three in the same 5.5 hours, on four in the same 6.3 minutes.

Stamps were eight characters of milliseconds until September 2026. The ninth character went to precision rather than range, which suits what the stamp is for: a stable name spread through the time it is actually used. At microseconds, every position turns at a useful rate. Eight-character stamps keep their spelling and decode as milliseconds. Bytewise order holds within one width, so comparisons across widths use the decoded instant.

Collisions advance the clock rather than adding entropy:

def mint_incepted(existing: set[str] | None = None) -> str:
    """Fresh nine-character stamp, advanced one microsecond past collisions."""
    ...
    micros = epoch_micros()
    while True:
        stamp = encode_width(micros)
        if stamp not in existing:
            return stamp
        micros += 1

For serialized callers sharing an up-to-date existing set, two tasks minted in the same microsecond get adjacent stamps: still sorted, unique inside that set, and each stamp remains a pure function of one integer. No random suffix, no second identity component to reason about. This is local collision avoidance, not atomic allocation: two processes can read the same rows and the same microsecond, then mint the same value before either persists it. Fixed width is enforced as an error rather than a widening—an oversized value would silently break the sort property, so it refuses.

The rendered handle is KEY-INCEPTED, and only the stamp is stored. KEY derives from the current project’s rightmost segment at render time, so re-homing a task renames it for free; resolution matches on the stamp alone. The human-friendly part of the name is a projection, never data.

My daughter started in the junior taekwondo class. I was helping her with it, then joined the adult class about a year later.

Now we both practice. She is the blue belt; I am the yellow.

We have our own classes and our own progression. Being her dad did not give me a head start on the belts.

On September 19, 2026 we both competed at The Warrior’s Legacy, a National Martial Arts Alliance tournament in Eagan hosted by our own school’s Senior Master Jena Bushey. My daughter took first place in her division. I took second in sparring. The order held.

why also tag? why not e.g. tag=abc[&tag=…]

The resolution was one key, repeated, so a single click’s #tag=gaming and a multi-select’s #tag=gaming&tag=infra have the same shape at every count, needing one parser and one restore path.

That fix is the newest entry in a habit I can trace across years of my own repositories: two representations of the same truth appear, one of them gets deleted, and the survivor becomes the source everything else is derived from.

settings = __import__('settingsd').install(__name__)

.claude/CLAUDE.md -> ../AGENTS.md
.codex/AGENTS.md  -> ../AGENTS.md
.gemini/GEMINI.md -> ../AGENTS.md

trap 'vps_exception ${LINENO} fatal "caught SIGTERM"' TERM
trap 'vps_exception ${LINENO} fatal "caught SIGINT"' INT

Ctrl-C halfway through a template build lands in the handler that deletes the half-built template. An explicitly routed pacman failure with /dev, /sys, and /proc bind-mounted into a template rootfs unmounts them before the rootfs is deleted, because the unmount handler was registered second and runs first. Unchecked shell failures could bypass the path; the handler stack was manual compensation, not language-level try/finally.

Over the years, that approach kept reappearing in other work: btrfs subvolumes, a vim plugin directory, a venv builder, a game-server fleet, and now a Python installer’s append-only receipts.

vim/autoload/plug.vim
vim/autoload/plug.vim.old

cleanup () { (($1)) && mv $VIRTUAL_ENV{,.$$} && rm -r $VIRTUAL_ENV.$$; } >&2

In Python Spice’s process wrapper, the POSIX path starts the command in a new process group and a small shell guardian in a separate session. The guardian waits on a pipe whose writer belongs to the Python parent.

Normal completion writes a newline-terminated marker. A successful read disarms the guardian. If the parent disappears and the pipe reaches EOF without that marker, the guardian sends TERM to the command group, waits a quarter second, and follows with KILL if the first signal succeeded.

The normal wait adds no polling loop to Python. The pipe’s lifetime carries the signal. A separate executable also avoids running a custom Python child after forking a process that may already have threads.

The group matters because its leader can exit before descendants that still hold output pipes. Cleanup targets the process group rather than assuming that a finished leader means all its work is finished. Reaping the direct child remains a separate obligation.

There are explicit limits. This guardian is the POSIX implementation; Windows retains a different cleanup path. If spawning the guardian fails, the helper returns an unarmed guard. Processes that leave the command group are not covered merely by being descendants. The guarantee belongs to the group and a successfully started observer.

The implementation also waits for or terminates the guardian when disarming it. A lifetime helper should not become the process the caller forgets to collect.

This mattered when a Spice hook was validating the index generation while another internal probe inspected the repository. The observation itself could move the artifact being checked.

The shared subprocess boundary sets an environment policy for Python-managed Git children:

child_env[GIT_OPTIONAL_LOCKS_ENV] = "0"

It copies the child’s environment before setting the value. It does not modify the parent process’s environment or the user’s shell configuration. The command’s executable basename identifies the Git children to which the policy applies.

This disables optional locking work such as an opportunistic index refresh. It does not remove the mandatory locks needed by actual Git mutations. The scope is every internal Git child passing through this boundary, not a list of commands guessed to be read-only.

The distinction is useful whenever observation and mutation run concurrently. “This command does not change my files” is weaker than “this command cannot change the identity of an artifact another process is validating.” The index is maintained state even when the visible question is only about status.

Spice’s checked-out-branch guard cannot make that assumption. A caller can update a ref without declaring the old value. The hook input can then contain the zero object ID, even though the ref already exists. A rewind can look like creation if the guard trusts that field.

During the prepared stage, the reference still holds its pre-transaction value. The guard resolves it from the repository before deciding whether the proposed value would abandon commits already shared with the branch’s upstream.

The parsed update deliberately retains only new and ref. It still requires the three-field input grammar, but does not carry the misleading old value farther into the decision.

The upstream also needs an exact source. Spice’s per-process Git configuration can redirect apparent tracking information, so this guard reads the branch’s pairing from local repository configuration instead of trusting a shadowed @{upstream}. It does not assume the remote is named origin or the branch is named main.

This is a guard for the current checked-out branch, not a universal policy for every reference transaction. Appends that retain the old tip can proceed; a rewind requiring an upstream judgment cannot silently pass when the declared upstream cannot be resolved.

The repair made those evidence sources explicit. The hook input describes the requested transaction. The repository supplies the state against which this particular guard has to judge it.

Python Spice moved replayable Serve observations into a separate projection store. Durable team and directive authority stayed elsewhere. A corrupt, missing, or incompatible projection could then be discarded without discarding the decisions it was displaying.

A rebuild populated a fresh staging database first. Readers could retain the previous servable generation while that work ran. Only after population finished did the implementation copy the complete family’s rows into the published database inside one transaction, together with its generation and status.

That is an atomic row publication, not a filesystem rename of the live database. A failed staging callback never copied partial rows into the live family. The status remained explicitly stale if older data was still servable, or unavailable if there was no usable prior generation.

The integration tests seed authority and observation data, discard the projection, rebuild it, and compare the resulting combined view. Rebuilding must not reinterpret durable decisions as though they were merely observations that could be recreated from whatever transcript happens to remain.

Retention matters. Transcript-derived activity can be rebuilt from retained transcript bytes; deleting the source limits what any rebuild can recover.

The separation made failure handling simpler because the ownership was specific. This file could be recreated. The files carrying authority could not be treated the same way.

The task-board observation code therefore pairs the logical revision with a store generation derived from device, inode, and change time. Between observations, a different generation requires another read even if the logical revision has not advanced.

The coherence check during an export needs a different physical witness. Exporting through the backend can itself write the store. Including change time in that comparison would make an ordinary successful read appear to have crossed a replacement. Across the export, the code compares device and inode instead.

Both witnesses come from one stat result at each boundary. Taking separate stats for the fields could combine evidence from opposite sides of a file replacement and call it one observation.

These witnesses have explicit limits. An inode can be reused, which is why change time helps between observations. Coarse timestamps can still collide. The across-export identity check cannot detect every unlink-and-recreate case that receives the same inode during that single interval.

The two comparisons serve different purposes: deciding when to rebuild a cached board, and checking whether an export crossed a store replacement. Both work alongside the logical wake revision.

The fix, from the Spice harness’s transcript reader, is to report two offsets for each pass:

• end_offset—where reading stopped. This may sit inside a half-written record, and that is fine, because its consumer is forensics: a static or bounded read can still show the partial tail. A live cursor must never resume from it.
• resume_offset—the byte after the last terminated line. This is the only offset a resuming reader may use. The two differ only when a pass delivered an unterminated final line.

Forward reads for live cursors go further and hold the unterminated tail back entirely:

if hold_partial_end and not raw.endswith(b"\n"):
    # A writer mid-flush leaves its last line unterminated. Resuming
    # after that prefix would decode it as garbage and then decode the
    # rest of the same line as more garbage, so the complete record
    # would never be seen. Leave it for the pass that finds it whole.
    handle.seek(offset)
    break

Two more rules complete the contract. Replacement is detected by filesystem identity—device and inode—not by size, because a rotated-and-recreated file can easily be larger than the old cursor position and a size check would happily read garbage from the middle of an unrelated file. Replacement (identity changed) and truncation (cursor offset beyond current file size) both reset the cursor to zero rather than guessing.

Spice uses this for live Claude and Codex transcripts. Separating bytes observed from complete records lets a read show the unfinished tail while keeping the next live read at a valid record boundary.

Spice’s readiness code stores ready_at for later transitions into READY. The timestamp belongs with the mutation that exposes the work. Writing it in a second command would leave a window where Serve could observe a newly ready task with its old age.

Dependency edits that leave readiness unchanged retain the existing origin. An unrelated modification must not reset a task’s wait. When completion of one task exposes dependents, the code prepares their transition stamps before the final blocker completes, rather than requiring a fallible write after that irreversible completion.

Those are two ordered writes, not one transaction. If the final completion fails, the dependents remain blocked with prepared timestamps. Retrying through the same completion path replaces those stamps before trying again. Completing the blocker outside that path can leave the earlier origin in place: the resolver trusts ready_at; it does not reconstruct when the blocker actually finished.

Initial readiness also has existing evidence: the native entry timestamp and any wait or scheduled horizon. The resolver uses the latest applicable origin when there is no explicit later-transition timestamp. It does not substitute the current process’s startup time.

That keeps queue age stable across Serve restarts. A malformed timestamp or a ready row with no usable origin is an error; silently using “now” would make old waiting work look newly eligible.

The wider allocator has other ranking inputs. This note concerns only its clock: before using age to prevent starvation, establish which state is aging and make the transition into that state durable.

• git rev-parse --git-common-dir finds the state shared by every worktree: objects, refs, the main config file, and repository-wide tool state.
• git rev-parse --git-dir finds this worktree’s HEAD, index, config.worktree, and operator receipt.
• git rev-parse --show-toplevel finds files meant to be visible from this checkout, including generated hook shims and live steering inputs.

Without a configured total-state backend, the current Python implementation of Spice uses all three. Its path resolver puts shared managed state under <git-common-dir>/.spice, durable worktree-local state under <git-dir>/.spice, and mutable visible state under <worktree>/.spice.

Hook installation belongs to the third root. The initializer plans this hook-selection spine in order:

1. enable extensions.worktreeConfig in the common config;
2. record core.bare=false in this worktree’s config;
3. write executable shims under <worktree>/.spice/hooks/;
4. set this worktree’s core.hooksPath to .spice/hooks.

The hook files exist before Git is pointed at them, and one worktree can be initialized or reversed without silently changing which hooks another worktree runs. The one shared mutation, enabling worktree config, is tracked separately from the worktree-local selection that depends on it.

This corrected an earlier design of mine that put the hook directory under the common Git dir and selected it through shared local config. That design handled the .git indirection but assigned a worktree choice to repository-wide state. It solved the path problem and missed the ownership problem.

The portable rule is not “always use the common dir.” Ask which scope owns the fact, then resolve that scope through Git. Objects and refs are common. HEAD, the index, worktree config, and installation receipts are not. Files an operator should see in a checkout may belong in the worktree itself. .git is not one directory, and “the real Git directory” is usually the wrong question.

The fix, from the Spice harness:

@contextmanager
def sqlite_connection(path, *, busy_timeout_ms=None, wal=False,
                      ensure_parent=False):
    """Yield a connection that commits on success and always closes."""
    if ensure_parent:
        Path(path).parent.mkdir(parents=True, exist_ok=True)
    connection = sqlite3.connect(path)
    try:
        if busy_timeout_ms is not None:
            connection.execute(f"PRAGMA busy_timeout = {int(busy_timeout_ms)}")
        if wal:
            connection.execute("PRAGMA journal_mode = WAL")
        yield connection
        connection.commit()
    except BaseException:
        connection.rollback()
        raise
    finally:
        connection.close()

Commit on success, attempt rollback on failure, and close in finally. BaseException rather than Exception includes a KeyboardInterrupt mid-transaction. A failed commit also enters the rollback path. If rollback itself raises, finally still attempts the close; if close raises, that error propagates. The helper guarantees the cleanup path, not successful cleanup or preservation of the original exception as the one the caller catches.

The same module avoids repeating schema setup on every open. ensure_sqlite_schema_once keeps retrying the schema initializer until the first successful commit, then skips it for that path for the rest of the process. That cache assumes one schema owner per path; it does not identify the file currently at that path. A double-checked lock keeps the cached path to one set-membership test when validate is absent. Callers that supply a validation callback deliberately open the database and run that check even on a cached path, catching a file replaced or advanced by another writer. The helper opens WAL so a reader and the single writer can proceed together. The path is recorded only after the DDL commits, so an initializer that raises leaves the next caller to try again rather than marking a database that was never built.

ACK dMbnngX3j: <what changed or was captured>

The header parser requires ACK as a standalone ALL-CAPS token followed, in order, by one or more key-shaped tokens (optionally carrying a -N collision suffix). NACK is the same grammar with opposite sign, and both polarities are walked in source order. The hot path is a plain "ACK" in text substring check, so ACK-free replies cost one scan.

The grammar’s real work is tolerating markdown reality. Models bold their headers (**ACK k:** ...), decorate them as list items or headings, and pad them with filler (“ACK inbox key dMbnngX3j”). Each tolerance is an explicit consumption rule with stated widths—wrapper characters, key closers, separators, filler words—rather than a regex shrug, so every reader of the grammar parses the same header the same way.

Then two guards keep prose about the protocol from acting as the protocol. The use-versus-mention guard discards a candidate ACK that context shows is being talked about rather than issued: quoted or backticked, preceded by explicit negation, or sitting in a clause window with hypothetical words or narration words:

return (
    textcontext.has_explicit_negation_before(text, ack_pos)
    or bool(_ACK_HYPOTHETICAL_WORDS & set(recent))
    or bool(_ACK_NARRATION_WORDS & set(recent))
)

“I could write ACK here” does not acknowledge anything. Neither does an example, a phrase, or a saying—the wordlists are cheap and the failure class they close is real. A keyless ACK: shaped like a directive is detected too, as its own failure: said ACK, named no key.

The suppression walk is the second guard. One shared iterator decides, per line, whether a control token is displayed rather than issued—inside a code fence (fence character and size matched), a > quote, 4-space indentation, or a rendered path:line: source-context line. Shown control tokens never act. The doctrine is stated at the trim helper, which refuses to strip indentation off a segment’s first content line:

four spaces there is the difference between code being shown and a directive being issued

Every reader must drop exactly the same lines, so the walk exists once.

The prose is the interface. There is no extra tool call on the agent side, but there is still a protocol: token, key shape, header tolerances, mention guards, and suppression rules. The shared parser makes its readers agree. It cannot prove that the work described after an ACK actually happened; that needs its own evidence.

The whole reason it exists is to power Grit. It came out of a dumb loop: I was trying to squeeze as much out of Codex as I could while keeping a project with several languages, and VR in the middle of it, from becoming horrendously slow to develop or to ship. It let several agents share one machine and reuse pre-warmed test beds without exploding my disk. Mostly it is about managing entropy, keeping the project trending the way I want, because it cannot get there in one move and never without mistakes.

The session reader came next. It read the provider’s transcript so an agent could recover what it had been doing before compaction: the conversation, commands, failures, changed files, and commits. Then a mailbox let me leave steering for a particular worktree. The agent’s command wrapper exposed it on stderr before and after commands, preserving stdout for whatever the command was supposed to produce. A later version checked during long-running commands too. I could correct a running agent without rebuilding the conversation around every correction.

The browser initially put the assistant’s replies beside that mailbox. Speech made replies audible while work continued. Work ledgers, Taskwarrior, agent launching, and shared lanes grew around the same loop. By June I was pulling the coordination layer into a separate project. Grit kept its Unity, device, and runtime verification code; Spice could invoke those repository-owned commands without needing to understand the game.

Spice Harness is the agent harness I built through Infima Labs, my small personal business, to watch that work and steer it. The initials stand for Software Production, Integration, and Control Environment. It keeps the record of what happened separate from the instructions about what should happen next.

I use it mostly at work. The usual starting point is one Slack or Jira link and perhaps a sentence of context. From there an agent can follow the links, materialize the ticket, discussion, document, or build it finds, and keep moving until the work is near a pull request. I have used it less outside work.

A typical evidence path might begin with a Jira issue that points to a Slack thread, which names a repository and a failed build. Gotta stores each result once, gives it a handle, and can reopen only the relevant section later. Its transcript search and leads view point to the next likely source without making the agent fetch and read the whole chain again. The session becomes the agent’s workspace across those systems without a separate MCP setup for each one.

The name is the command grammar. gotta read, gotta search, gotta todo append, and gotta oops read as sentences about what needs to happen, whether the next step is finding evidence or recording a mistake.

Early on, gotta ate its own oops: after a task ran, the friction it had recorded became the input for polishing the task. A daily run’s exhaust was the next day’s to-do list for the run itself. That loop moved into Spice with me.

content/<sha256>/
  data
  meta.json
  names/<preferred-name> -> ../data
  logs/<timestamp>       -> ../names/<preferred-name>

gotta read artifact:README.txt@2bc5c32d9c42 --section Installation

My patch addressed two paths in the Go nftables library. Anonymous, constant, and interval sets could emit big-endian key metadata even when their key byte order had been explicitly set to native endian. Maps also lacked a way to emit the data byte-order metadata used for their values.

The first correction gave explicit native-endian keys precedence over the set-kind fallback. The second added DataByteOrder and emitted the corresponding userdata value for maps. The decoding path read both key and data byte-order fields back into the Go representation.

Those userdata fields told the nft userspace tool how to reconstruct a human-readable rule. They were not a replacement for the element bytes themselves. Changing the data to compensate for a misleading listing would have risked breaking the behavior that was already correct.

The patch included round-trip system tests for several set and map forms, including preserving the existing big-endian default when no explicit native-endian setting was supplied. The public report also describes the display symptoms for marks and interface-name maps.

The PR remains open as of September 21, 2026.

Couch co-op is big in our family. SpiderHeck, Don’t Starve Together, BattleBlock Theater, and plenty of others have been part of it. Xbox is still a big part of our house.

When we wanted several Minecraft players on one Linux box and one TV, I wrote a window manager so each controller could have its own part of the screen.

My youngest has reached the point where I can barely beat her, if I beat her at all. We play SpiderHeck almost every day lately, and she seems to win most of the time even when her older brother is playing. He is already scary enough.

She caught me off guard years earlier. I let her play Skyrim when she was young enough that I did not expect her to get very far. I left the room for a little while. When I came back, she had found a powerful dragon and was kiting it through the window of what I remember as a church. It had about a quarter of its health left.

She finished it. I asked what she was going to do next. She collected the loot and said she was going to find the next one.

The idea was to collect enough text to find a safe boundary, render that chunk, and continue. A line of ordinary prose looked manageable. Fences, tables, frontmatter, and whitespace made the word “safe” progressively more complicated.