My/AI/Agent/Chief of Staff/Scribe/Log/26/08/18 Tue

• 2026-08-18 Tue
  • First day of this space, and the first with the seat held in a tmux session rather than a herdr workspace.

  • A standing rule outlasts a warning

    • Two corrections arrived after the commit each was meant to prevent. One named the commit convention; one named a file that was not the scribe's to commit. Neither was late through inattention — the channel carrying them delivered late, and the sender saw a success either way.
    • The file stayed out of that commit regardless. Staging named paths cannot pick up a path nobody named, and the git status run after staging showed it sitting unclaimed, which is what prompted the check. The rule ran while the warning was still in flight.
    • So where a rule and a watchful supervisor would both serve, the rule is the one that holds while the scribe is mid-turn and cannot see the tree. A warning is a second line of defense, not the first, because it depends on someone looking at the right minute.
    • The same reasoning governs a note about state. A handoff section asserting what the tree held was wrong within the hour of being written; one naming the command that answers the question does not go stale. Write the instrument, not the reading.

  • Verify by reading the result, not the instruction

    • Confirming a commit means reading what the commit contains — git diff-tree --no-commit-id --name-only -r HEAD — rather than trusting the git add one believes one ran. The two answer different questions, and only the first survives another agent writing into the checkout between them.
    • The same applies to a page's own claims. Extract its links mechanically instead of reading for them; a link read past is a link not checked.
    • Where a version is asserted, ask the machine rather than the page. A page claiming tmux/v/3.7b was checked against tmux -V, which is a different source from the document making the claim.

  • A count answers a different question than it appears to

    • Two links on a page arriving today carried exactly one prior reference each, which is the count that separates an established page from one the arriving page is about to invent.
    • The count alone cannot tell those apart, because the arriving page is itself one of the files the count includes. What settles it is opening the other file: one reference sat in an existing question page, the other in a journal from February. Both predate the page claiming them, so neither was manufactured.
    • It happened twice in the day, which makes it a pattern rather than an incident. The second time, a count of Person/Steve Yegge/Agent page files came to 36 against another agent's 35. Splitting the count found 35 files under Agent/ plus one parent-level Agent.md, so the other number was right and mine had counted the parent as an instance. Reporting the disagreement would have sent someone to correct a correct figure.
    • The discriminator was the same both times: ask what exactly the count ranges over, and whether the thing being counted is inside its own population.
    • This is the costly shape here, more than a wrong measurement — a correct measurement of a slightly different question, arriving well-formed with a number attached. A number carries conviction that a sentence does not.

  • A rule you exempt your own writing from has a hole nothing reports

    • Both resume notes in this repository state that no bare identifier belongs anywhere, and that a commit SHA takes a subject slug and a link. Both notes then carried a bare SHA.
    • The rule was neither forgotten nor disputed. It was applied to commit messages, where it was learned, and not to the notes that state it. The writing closest to a rule is the writing least often checked against it.
    • Grepping for the rest of the hole found it wider than the notes. Six bare SHAs sit in prose across five graph pages, and all six resolve — git cat-file -t returns commit for 1245c96, 3e4245e, 5e5012a, 84f0092, c47ab2f and f086c38. One seven-hex prefix matching this repository by chance would be remote; six is not chance. Those pages cite this graph's own history, and the rule has been broken in the graph proper for months.
    • Nothing reports it, because the rule lives in prose and prose does not run. The route that found it is the transferable part: grep your own output for whatever you have told others not to do, beginning with the document that states the convention. The rules we write down are the ones we stop noticing we break.
    • The mechanical version is not cheaply available, for the graph's usual reason. A [0-9a-f]{7,40} pattern inside backticks matches 31 times across the pages: 18 occurrences of the six real SHAs, 84f0092 alone accounting for eight, and 13 that are binary literals from a two's-complement page, an inode number, a byte count, and ed25519, which is a key type. That is wrong about two matches in five by occurrence, and about eight of fourteen distinct tokens. Dropping the backtick requirement carries it past two thousand tokens. Far past usable either way.
    • Scope is unstated too, and no check settles that. A prose reference wants a slug and a link; quoted terminal output does not, because rewriting a transcript falsifies it. Settle which before building anything.
    • The six tokens listed above are the distinction in miniature. They appear here as specimens under examination rather than as references to commits, so a slug and a link would be wrong for each — and a check on the obvious pattern would flag this page. A rule about identifiers cannot be enforced without first saying what an identifier is doing in the sentence.

  • An absence is not a mechanism

    • A job window vanished from the session between one check and the next, and the inference drawn was that windows close themselves when their work is done. They do not. The seat closes them by hand, and that act is what marks an item finished.
    • Believing otherwise inverts two readings at once: an open window becomes evidence of live work when it may hold a finished item nobody closed, and a closed one becomes evidence of completion when it only shows that someone acted. Neither holds.
    • The error has the same shape as a check that reports confidently and wrongly. Something was observed, a mechanism was supplied to explain it, and nothing in the observation had ruled the mechanism in.

  • A heading should name the finding

    • A journal heading written today made a reader work through three bullets to learn that the subject was Google Drive at all, and drew the objection that this kind of verbiage is obscure.
    • The correction was already in hand before the heading was written. Person/codekiln holds a standing preference for plain writing over figures of speech, and it had been applied to prose and not carried to titles. A preference held but not extended to a new surface fails in the same way as one not held at all.
    • The graph's own guidance is part of the cause. Logseq/Journal/Editorial headings asks for titles that are wry and magazine-like and lists wordplay first among the ways to find one. The journals mostly do not do that — recent topic headings run six plain to three allusive — so the page describes the exception as though it were the rule.
    • A heading earns its place by letting someone scanning the day stop reading. One that has to be decoded first has taken that back.

  • The journal carries the change log, not agent narrative

    • The three topic blocks written into today's journal were removed, leaving the grouped change log by itself. The question open all day had been whether such a block should be in Person/codekiln's voice or an impersonal one, and the answer was neither: the substance belongs on the page, and the journal records that the page exists.
    • A day's entry is therefore complete with no prose in it. What reads as a thin journal is the intended one, and a scribe filling that space is adding to the graph what nobody asked for.

  • The journal's narrative is codekiln's to write, and theirs alone

    • The rule that an agent writes no narrative into a journal has a positive half that is easy to lose: Person/codekiln does write it. They added a top-level block on the public and private halves of a knowledge garden above that day's [[Filed]], hours after deleting three that an agent had written.
    • Stated only negatively, the rule reads as though narrative does not belong in a journal at all, and the next agent to open the file sees prose the record says should not be there. The obvious repair is to delete it, and it would be done in good faith and reported as tidying.
    • So both halves together: an agent neither writes a narrative block nor removes one. Prose above the change log is the human's, and its presence is not evidence that anything went wrong.

  • codekiln takes they/them

    • Their gender is undisclosed and they/them is the default. It is not a question awaiting an answer.
    • This was settled in conversation and written nowhere, which is how it nearly escaped. A chief-of-staff occupant used "him" across several briefs in one day, the scribe copied it into a handoff note before catching it, and two more instances sat inherited in that note from a previous week. The graph is public, so the failure mode is a real person misgendered on a page anyone can read.
    • A wrong guess is worse than the neutral default, and a name is not evidence. Where a document already carries the error, fix it rather than leaving it because someone else wrote it.

  • Grouping labels are terse, and grouping is page-wide

    • The labels chosen were agents, gdrive and tmux: lowercase, abbreviated, and named for the subject rather than for the kind of work done to it. gdrive rather than google drive, and agents rather than the agent supervision a scribe picked on 08/13, which is still open for renaming.
    • Grouping is a decision about the day rather than about a section's length. Updated held a single item and took a label anyway, as it does in journals/2026_08_13.md. Once any section groups, they all group, so whether one section has enough items to deserve it is not the question.

  • A commit trailer is an authorship claim, not a formatting habit

    • Every commit here ends with a Co-Authored-By trailer, and one today does not. Person/codekiln edited a journal by hand and the scribe only staged and committed it, so the trailer was left off.
    • The reason is that a trailer is a structured field which forges and review tools read and display, rather than prose a reader weighs. Putting an agent's name on a person's own statement of preference is a false claim in a field built to be believed, and a caveat in the commit body does not retract it.
    • Claude Code treats it as configuration rather than convention: the settings.json schema carries an attribution object whose commit and pr fields hold the trailer text, and an empty string hides it. includeCoAuthoredBy is the deprecated form of the same switch.
    • So the trailer follows who wrote the content, not what the log looks like. Uniformity is worth having across entries of the same kind, and these are not the same kind. Do not tidy the exception away.

  • A handoff is complete when the file is committed

    • The commit is the completion signal, and the other party can read it from git log without being told. An acknowledgement is a courtesy. Waiting on one makes completion depend on both parties still existing, which neither can guarantee.
    • A worker handed a page over and asked for confirmation as the last thing it was waiting on. By the time the checks were done and the commit pushed, its session had left the registry and the reply could not be delivered — it had been closed on the commit landing, which is the right standard, while the acknowledgement was still in flight.
    • Nothing was lost, because the work is in the graph. But it closed without learning that, and anyone watching for the acknowledgement rather than for the commit would read the silence as a failed handoff. Hand over, then close.

  • An instrument can be right when captured and wrong when read

    • ListAgents names the tmux session each peer sits in, and went on reporting the old name after the session was renamed underneath it. That field is captured when a session starts rather than read live, so it ages silently while continuing to look authoritative.
    • Use it for which agents exist and for pane references. Ask tmux for anything about the session itself: tmux display-message -p '#{session_name}'.
    • The same error wearing different clothes: that a settings key is absent from a local settings.json says nothing about whether the key exists. An unset key and an unsupported key are indistinguishable from the file alone, and only the schema answers what the file cannot. Flagging such a claim as unverified is right; reading the file's silence as evidence either way is not.
    • Both are the shape this graph keeps producing — a sound-looking instrument answering a question it was never measuring. Before trusting a field, work out when its value was determined.
    • A measurement of your own can age the same way, and you can be the thing that ages it. The bare-SHA count above was first reported as 31 occurrences split 18 and 13, and had been measured as 24 split 12 and 12. Both were correct: the count was taken, then six SHA specimens and one ed25519 were written into this page, then the earlier number was reported as though it still described the graph. git grep at the two commits confirms it — 24 before the specimens landed, 31 after.
    • So the discipline is not only to say what a count ranges over, but to check whether anything has changed the population since it was taken — including your own edits between measuring and reporting. A number describes a moment, and writing about a thing can put you inside the set you are counting.
    • It recurred twice more inside the same investigation. A line-based version of the count read 22, then 23, because this page gained a line about the count in between; a second agent measured 20 at a third moment. Nobody was wrong. A count over a corpus that contains your own notes cannot be quoted without the commit it was taken at, because the act of writing it down changes it. Cite the commit alongside the number, or expect to defend a figure that was true when you ran it.