24 hours of a zero-person company

Read the source — the Vocion framework is open.

Setup

A zero-person company is an autonomous workforce that ships production software for 24 hours with no human in the loop except at approval gates — everything wired to version control, nothing ad-hoc.

One dedicated Mac Mini. Claude Code running headless as the workforce supervisor. A Fable board session handles strategy; Opus (the CEO) dispatches work, alongside Opus specialists for the two strategist roles and the core engineer; Sonnet workers execute (writer, docs engineer, demo builder, distribution, QA, historian, video producer); Haiku does the bookkeeping (analyst). Every outward action — posting, emailing, publishing — goes behind a human approval queue. Every code change is a PR. Policy is enforced by git hooks. The goal is to ship indexable, accurate content and technical surfaces that help engineers and AI agents find Vocion when they search for how to build and run a team of agents in production.

The run targets queries in company/KEYWORDS.md (33 scored, 10 TOP-10). Each agent reads from and writes back to company/: state, backlog, learnings, the ledger. Machine logs live in company/ledger/cycles.jsonl. See https://github.com/vocion/vocion-core for the framework code and demos. Read the approval workflow post and the autonomy levels guide for how the HITL gates work in practice.

How it is wired

The registry. Eleven agents defined in .claude/agents/*.md, each pinned to a model (Opus, Sonnet, or Haiku) — the board's Fable session runs from a prompt, not a registry file. The workforce supervisor (bin/run.sh) stages each cycle, reads role and prompt, runs an agent, collects logs, moves to the next.

HITL queue. Human approval happens through files in company/approvals/pending/. Each is a decision point: a PR to review and merge, a post draft to approve for social channels, an architecture decision, a prospect mention, a spend request. The CEO and workers file items; a human moves them to approved/ or rejected/; the next cycle executes approved items or extracts learnings from rejections.

The ledger. company/ledger/LEDGER.md records every cycle: what was dispatched, what shipped, what failed, what was queued, spend. cycles.jsonl is the machine-readable companion: timestamps, token usage, model calls, cost.

Learnings. company/LEARNINGS.md captures what worked and what did not — dogfooding failures, API issues, docs that need fixing, competitor URLs that went dead. Cycles read it; future cycles do better.

Want to see the gate in practice before you wire up your own? Read the review queue API — it is the mechanism every approval item below runs through.

On cadence: cycles run about three per hour, roughly twenty minutes each, not one per hour — the headings below are labelled by cycle number and real elapsed run-hour, not by clock hour.

Cycle 1 — run-hour 0.0 (board)

Fable board session read all state files and vocion-core docs. Verified ground-truth facts: core at tag v2.37.0, demos at v2.36.0. Found and corrected a false claim carried by the marketing pages: they advertise a named policy engine and a named cloud guardrails product, and the code implements neither. Corrected company/EDITORIAL.md to forbid those claims.

Dispatched the seo-strategist (Opus, 15-min box). Strategist ran 13 web searches, rewrote company/KEYWORDS.md (33 rows, 10 TOP-10), wrote company/reports/baseline-llm-answers.md (what LLM tools return when asked our target queries), added 3 lines to LEARNINGS.md. Board approved the swaps.

Board wrote company/reports/board-001.md (strategy: 10 queries, 4 content pillars, risk map, 3 forbidden areas, check-in list for the human). Backlog reordered (15 items for the first 6 hours with owner/model/acceptance criteria).

What went wrong: MCP mirroring was supposed to happen here. The vocion MCP server returned HTTP 401 on the configured Authorization header. We are dogfooding our own product and it will not let us in. This blocks the add_learning and propose_action tools; the cycle fell back to file-based updates.

No code merged. No PRs opened. Spend: ~$5 board + ~$1 strategist (actual in cycles.jsonl).

Cycle 1 — run-hour 0.1 (CEO)

Opus CEO read backlog and approvals. No human decisions to execute (approval queue empty). Dispatched four backlog items:

B-002 seo-strategist: Wrote 10 complete briefs in company/briefs/ — one per TOP-10 keyword. Covers deployment + approval, agent versioning, open-source platforms, human-in-the-loop, LangGraph alternative, Temporal, team building, registry. Writers are unblocked for cycle 2.

B-003 docs-engineer (Sonnet): Opened a pull request against the marketing site repository. Shipped 5 of 6 scope items: new NEXT_PUBLIC_SITE_URL env var (fixed a real bug where blog canonicals pointed at the app host instead of the marketing domain), full sitemap including /compare and all features, JSON-LD (Organization + WebSite + SoftwareApplication on home, Article + BreadcrumbList on posts and docs), generated public/llms.txt and llms-full.txt via new build script with a hard-fail guard against Cedar/Guardrails claims, AI-crawler groups in robots.ts. npm run build passed. Static pages: 347/347.

What went wrong: Vercel preview deployment for this PR failed with "Git author must have access to the project on Vercel." The commit author identity is correct, so this is a Vercel org/git authorization setting. Consequence: no preview URL for any www PR this run until a human fixes it. Local build still passes, so QA is degraded but not blocked. Escalated as approval item 004-vercel-preview-access.

B-010 core-engineer (Opus): Opened PR https://github.com/vocion/vocion-core/pull/215. Shipped: AGENTS.md (setup sequence, workspace paths, entity types, how to add agents/skills/approval gates, do-not-touch list), root llms.txt, README audience section, proposed 20 repo topics. No feature code, no schema changes, per the board's bounds. Verified all command examples against source. Found one docs bug (not fixed, backlog candidate): README eval example shows npm run eval:run --workspace @vocion/core but the real form is … -- --dataset <slug>; CLAUDE.md root documentation predates the monorepo.

What went wrong: Core PR CI queued at hand-off (7 checks pending). Next cycle must re-check and fix if red.

B-011 distribution (Sonnet): Filed three approval items: 001-repo-metadata-vocion-core (GitHub description, homepage, 20 topics), 002-repo-metadata-vocion-demos (same), 003-public-demos-name-prospects (high risk, a public-surface issue in the demo repos, filed for a human ruling — details withheld from this log by policy). Only human decision can proceed here.

Spend: ~$8 CEO + four subagents (actual in cycles.jsonl).

Cycle 2 — run-hour 0.5 (CEO)

Dispatched four workers. Writers shipped two posts (2,648 + 2,606 words published) into the run's rolling content pull request on the marketing site; the site build passed with both in place. QA caught four defects (author name, stray frontmatter key, dead link, description length) and cleared two false alarms. Found EDITORIAL.md's tag list stale; the draft was correct. Vocion-core #215's red CI traced to upstream; nothing to fix in the PR. Found internal-only documentation committed to the public core repository; escalated it to a human rather than reading or moving it, which is what policy requires and the more interesting half of the story. Added approval item 005-public-repo-internal-docs. Two more workers in flight at cycle end.

Cycle 3 — run-hour 0.9 (CEO)

Reviewed two pull requests held from cycle 2. vocion-demos#1 rescanned and found two issues that must not sit in a public repository: a code comment naming a prospect via a sibling demo's database name, and a workflow description referencing the private repository. Both fixed with a new commit and pushed again. A pull request for glossary and comparison routes scanned clean. Three marketing-site pull requests still fail their preview-deployment check for an access reason unrelated to their content; local builds pass.

Dispatched four workers, all landed. B-006 (writer) published ai-agent-versioning-audit-trail, 1773 words grounding every claim in vocion-core source and providing the schema and queries a reader can run. B-008 (writer) published eight glossary entries (agent-workforce-platform, autonomy-ladder, agent-registry, trust-rules, review-queue, workspace-versioning, learning-step, base-pack), each 270–314 words, verified against the loader frontmatter. B-043 (core-engineer) opened PR https://github.com/vocion/vocion-core/pull/218, removing stale Clerk references from README and CLAUDE.md. B-047/B-051 (seo-strategist) drafted two briefs for cycle 4.

The strategist found the autonomy-ladder enforcement code and discovered that the five-level policy has only one enforcement boundary: levels 1 and 2 gate every external action; levels 3, 4, and 5 are behaviourally identical. The glossary entry for autonomy-ladder was in QA that moment. QA verified the code fact independently and found the entry already correct. The guardrail fired and the work was sound.

QA passed all nine files with zero mechanical fixes. Found glossary documentation contradicting vocion-core ADR-0003, scheduled for cycle 4.

Shipped: one post and eight glossary entries into the rolling content pull request. Build passes. Spend: recorded in company/ledger/cycles.jsonl.

Cycle 4 — run-hour 1.3 (CEO)

Dispatched four workers. Two posts shipped: "Approve AI Agent Actions: The Review Queue API" (2,191 words) and "What an AI Agent's Autonomy Level Actually Gates" (2,152 words). Both passed QA, needing one mechanical fix between them. Cycle 3's briefs named exact source file paths; this cycle's writers started without clarification questions.

Autonomy policy declares five levels and labels all five, but enforces exactly one boundary between levels 2 and 3. Levels 3, 4, and 5 behave identically. The project's own documentation frames it the same way. Rather than work around the finding, both posts state it directly.

propose_action accepts only connector actions (gmail.send, hubspot.update, etc.) and nothing means "an approval item". Eight pending approvals stay unmirrored by decision, recorded as MCP rule 38.

Checked backlog B-055 before dispatch: @clerk/testing is actively imported by the E2E harness testing an Auth.js app, not dead. Escalated as approval 006-clerk-residue-arch-decision with options and blast radius.

Glossary review discovered two invented SDK surfaces with zero call sites repo-wide: defineOperation/Operation and defineSource.

Binding constraint identified: one human decision arrived in four cycles. Eight approvals now pending — three block external distribution, one gates a large core build, one gates the video pillar. The workforce shipped five posts, eight glossary entries, and one demo without a single ruling on the things that require human review.

Cycle 5 — run-hour 1.6 (CEO)

Dispatched four workers in one message: writers (B-042, B-007), docs-engineer (B-056), QA (B-014). Produced three drafts (an approval-workflow guide, two comparison pages) and QA'd the build log for the first time (three fixes applied). None published — CEO reached its budget cap with drafts confirmed ready and chose resumable state over an incomplete push.

The cycle's most valuable output was not content. It was catching that two of the company's own internal fact sources — EDITORIAL.md and LEARNINGS.md — each carried a false claim about the product. Both were corrected against source before reaching any public page.

The build log scan went clean on private-repo references for the first time in four cycles. But QA also caught a defect four CEO reviews had missed: cycle 1's section detailed an open public-surface escalation. It was redacted to status and risk level. Two wrong numbers were found and fixed: draft word counts in a cycle-2 quote (2,654 and 2,607) corrected to published (2,648 and 2,606), and the agent registry count (nine instead of ten).

B-056 shipped a documentation pull request deleting five documented-but-nonexistent features: the runtime_* MCP tool group (5 tools, zero call sites), the run_operation tool, an entire retrieval.yaml config file and provider table (absent from source), a false workflow-resource limitation, and a pre-ADR-0003 folder structure. The practice of grepping for call sites before documenting kept paying off.

Comparison-draft QA returned after the cycle closed: both passed. One contained a rule-5 breach — a fabricated endpoint count ("fourteen" instead of nine) cited to a page with no endpoint list. Corrected and properly sourced. Three pieces are now queued for publishing instead of one.

Approvals queue reached 9 pending. Zero have been ruled on in five cycles.

Cycle 6 — run-hour 1.9 (CEO)

Emptied drafts/ready/, publishing three pieces. B-042 shipped (2,067 words). B-007 both comparison pages landed (langgraph 1,302 words, temporal 1,707 words). Four workers shipped code: marketing site sitemap extended with glossary/comparison route enumeration; docs corrections (webhooks rewritten to real endpoint, workspace paths corrected, false workflow-resource limit removed). Build-log cycle-5 added clean.

Discovered two public flagship demos hard-error on the core they pin: commit 1daee5b2 removed the operations/ loader path in v2.20.0, but vocion-demos pins v2.36.0. Invalidated B-009 as briefed. Demo-builder updated the demo repo, found three independent defects plus a core gap, reported honestly that validation still fails, declined to invent workarounds.

Ten approvals pending, zero ruled on.

Cycle 7 — run-hour 2.2 (CEO)

Pipeline refilled: no drafts ready at start. No new approval items filed. B-066 corrected live production post that was stale, not wrong. related_version: vocion-v0.4.0 was accurate when published; v0.4.0 had both the operations/ layer and skill step. Applied reversible staleness markers rather than rewrites.

Strategist found docs/entities/workflow.md on origin/main already documents the gap ("There is no skill step"). CEO verified independently. DEMO-CATALOG.md corrected: a trade-show reel demo was marked publishable but was neither a workspace nor synthetic, and is not publishable at all. support-reply workspace validation still fails.

Twelve workforce PRs open, zero merged. A human has ruled on zero approval items in seven cycles.

Cycle 8 — run-hour 2.7 (CEO)

Three workers ran in parallel: QA retro-swept the content PR, a writer drafted a support-agent guide, a docs engineer fixed stale pages. The sweep existed because a settled fact — no per-skill approval flag; the gate is the approve step — was still asserted false in three staged posts, one stale demo file. Fixed all three; banned the source until it revalidates.

Seventh post shipped: Build an AI Support Agent With Human Approval, 1413 words. QA caught two defects a check misses: a path cited on an unmerged branch, and a fake action name plus interpolation syntax in example YAML. Lesson: verify paths against the published branch.

Eighth cycle, zero human decisions. Eleven pending, twelve PRs open, none merged.

Cycle 9 — run-hour 3.1 (CEO)

Three dispatches: two posts shipped into the marketing site's content pull request — the registry post (1,423 words) and the team-building post (2,500 words, built from a public docs fixture, not an unmerged demo). Both counts are whole-file wc -w against the published branch file, not the dispatch-time "body words" figure the ledger recorded for this cycle (1,359 / 2,412) — the two are different measurements of the same posts and this section states the whole-file one. The bookkeeping agent refreshed the metrics file and computed the run's total window, then reported it as time elapsed — writing that the run had expired with 22 hours actually remaining, and that "the halt is time-based, not financial." Corrected in place.

The CEO told the QA gate a post's description ran 277 characters and needed rewriting. The reviewer measured it twice, by two methods, got 147 — inside the gate — and refused the edit. The CEO's grep had matched seven description lines because the post's own example YAML repeats that key. The reviewer was right.

Cycle 10 — run-hour 3.4 (CEO)

Two pieces shipped: the agent-facing setup guide, post ten, and a legacy-content audit PR adding staleness notes to pages still describing a removed shape as current.

Three CEO errors, caught by cheaper workers. The historian was dispatched to rewrite a section that already existed — a wasted dispatch. A handoff claimed a content brief existed; one ls showed it did not. A six-cycle-old backlog line told the writer to run a command that does not exist and claimed a workspace check needs no database; the writer overrode the database claim from source, and a reviewer independently confirmed it — the third straight cycle a worker corrected a fact handed down as verified.

The counterweight: the audit found eight docs pages sharing one fabrication. The CEO checked that list against the other open pull requests, found six already fixed on one PR, and caught two PRs that will conflict on the same file — a check an audit of the main branch alone cannot make.

A reviewer also caught a quoted console line off by one space, the fourth consecutive cycle with that defect class. Zero human rulings, ten cycles in; every pull request still open.

Cycle 11 — run-hour 3.7 (CEO)

Two backlog lines died before dispatch. B-051 turned out already shipped: its brief targeted what-an-ai-agent-autonomy-level-gates, already on the content branch under that name. B-079's "three untouched pages" was one page once checked against all nine open pull requests, not the one the cycle-10 handoff had checked against — docs/api/runs.md was the only page left; the other two were already fixed on other pull requests.

A writer given the run's last unconsumed brief read the already-published post it would compete with first, built a section-by-section overlap table — same H2s, same trust.yaml example, same /api/v1/reviews calls — and correctly wrote nothing.

While comparing versions, the same pass found related_version: vocion-v2.37.0, carried by ten posts and eight glossary entries, cites a git tag that exists in neither tag lineage. origin/main is at v2.47.4; a bare git describe --tags with no ref had described a local checkout 23 commits stale. Fixed on the marketing site's pull request #21 before a docs pull request would have written the same wrong number into docs/ as a permanent convention. docs-engineer shipped the marketing site's pull request #29 (docs/api/runs.md), removing two skill-frontmatter fabrications.

Fifteen pull requests open, zero merged, eleventh cycle with zero human rulings. Spend ran to roughly $8.0, above the board's $7 target, on the version investigation — judged worth it.

Cycle 12 — run-hour 4.1 (CEO)

Cycle 11 handed off "content supply is exhausted." Checking it found the diagnosis half wrong: all 12 briefs were consumed, but company/KEYWORDS.md still carried three rows with no brief and no shipped page (self-hosted platform, learning from feedback, observability) — a zero-hit grep across posts and the content branch confirmed it. The deeper cause: all three of the run's vocion-core pull requests to date, #215, #218, #219, were documentation-only, and the framework's only starter workspace, templates/workspaces/meridian-revenue/, is a sales desk — while every page the run has published is about approval gates and review queues.

The cycle restarted the loop at the product end. https://github.com/vocion/vocion-core/pull/225 shipped larkfield-support, a fictional support-desk starter workspace and the run's first product-surface pull request, validated through the real workspace loader (132 of 132 tests passing, no core source touched). Three briefs were commissioned for the un-briefed keyword rows. A new role, product-strategist (Opus), joined the registry to own what to build next, alongside a small skill for checking work against open pull requests. An architecture-decision item on the sample-workspace registry went to the approval queue.

One finding produced no pull request. The source-code comment above WorkflowStepSchema in vocion-core still lists a workflow step type the schema itself does not have — the same fabrication this run has spent three earlier cycles scrubbing out of roughly two dozen public pages, still sitting uncorrected upstream.

Cycle 13 — run-hour 4.4 (CEO)

The run's content supply ran out: three writers consumed the last three briefs in one dispatch, shipping into the marketing site's rolling content pull request, build passing, all three prerendered in both locales. Files, pasted from the working directory, not generated: 2026-09-08-agentic-workflow-platform-self-hosted.md, 2026-09-08-ai-agents-that-learn-from-feedback.md, 2026-09-08-logging-and-observability-for-ai-agents.md.

The company found its own bookkeeping wrong: a stale pull-request count in its own state file had already propagated into the metrics file, making that file contradict itself. Corrected. The honest total, checked directly against the repos: 17 open pull requests across four repositories, zero merged, and zero of 12 pending approvals ruled on, in thirteen cycles.

QA caught two defects a naive check would pass: a link whose target file exists but whose route 404s, and a frontmatter key correct on one surface, wrong on another. A writer refused to quote a real docs line because it names a dead repository URL. The CEO withdrew a two-cycle-old recommendation after its premise was refuted, though the conclusion still holds on other grounds.

Cycle 14 — run-hour 4.8 (CEO)

Opened at $135.50 of $400 (33.9%), about 20.5 hours left, three workers dispatched.

For fourteen cycles running the company had opened its approval queue, found it empty, and written down that the humans were silent. That diagnosis was wrong. A human opened two pull requests in the framework repo during this run — one just 26 minutes after the workforce's own — and keeps filing issues there. The real cause: origin/main...HEAD read 0 0 after fourteen cycles. 20 modified and 67 untracked files, including all 12 approval requests, existed only on one machine's disk. Zero reviews on 17 pull requests and zero rulings on 12 approvals were not silence; they were an invisible record. Fixed by committing it and opening it as a pull request — the workforce cannot push to main, so a branch was the only route.

Pull request #30 on the marketing site marks four Langfuse flags (agent.dev, operation.run, workflow.step, source.oauth) reserved-not-emitted; all four have zero call sites. Build passed. The same worker checked the other ten open pull requests before touching a dead git clone URL, found it already fixed, and did nothing.

The strategist rejected half its own brief: connectors are not a gap — 15 built-in, documented — and substituted a real one: no shipped workspace template contains a workflow, approve step, or trust rule.

origin/main moved from v2.47.4 to v2.47.5 mid-cycle; a feature enum recorded at 12 keys is now 13. Two in-flight briefs were corrected. An orphaned worktree and an empty leftover directory were cleared.

Read the source — the Vocion framework is open.

Cycle 15 — run-hour 5.1 (CEO)

Three dispatches, one QA gate. The interesting one is a mistake the company caught on itself. A build brief written the cycle before told an engineer to create two skill files and delete an old operations directory in the support-desk demo. All of that work already existed — on an open pull request nobody had checked. The brief had been derived from the main branch, which by construction cannot see work sitting on other open branches. The coordinator noticed after dispatching, not before, corrected the engineer mid-task, and the engineer threw away its duplicate work and stacked its change on top of the existing pull request instead of filing a conflicting one. The check that would have caught this exists and is named in the team's own rules; it was simply run in the wrong order. The law going forward: run it before writing the brief, not after dispatching it.

The demo at the center of it now loads. The support-desk workspace that previously failed validation outright passes the framework's real loader, with its workflow expressed in the four step types that actually exist — sync, ask, approve, action — rather than a step type that had been removed from the schema some cycles ago.

The bottleneck moved. For most of the run the diagnosis was that no human had ruled on anything. That was wrong: the queue was simply not visible, because the company's own records had never been committed. Once they were, the first ruling arrived within about ten minutes. Now nineteen pull requests are open and none are merged — and merging is something the company is forbidden to do for itself. That is the honest shape of a zero-person company right now: it can produce, and it cannot publish.

One small, recurring detail: preview deployments on every marketing-site pull request still fail with the same one-line cause — a git author who lacks access to the deploy project.

Cycle 16 — run-hour 5.5 (board)

With 21 pull requests open and 0 merged, the board closed content production: 14 posts and 8 glossary entries already sit unmerged, and a fifteenth post could not be indexed either, so the last brief was dropped. New core and demo pull requests are banned until one merges; fixes to open ones stand. Remaining spend moved to what can finish without a human merge: video, making pull requests trivially mergeable, and this log.

The board also caught that a core pull request's unit-test job, read by everyone as failed, was actually cancelled at a ten-minute job timeout — every test printed before the kill had passed. A rerun, not an engineer, was the fix.

Cycle 17 — run-hour 5.7 (CEO)

The cancelled CI job was rerun in one command; it returned to pending under a new job id, confirming the timeout. The first build video was rendered, for the support-reply demo: 58 seconds, real ElevenLabs narration, queued as a video-publish approval item. The operate video did not fit the time box and was left honestly unstarted. METRICS.md was refreshed from primary sources; eight distribution drafts were queued.

The cycle also found the pull request carrying the whole company record for a human to read was three cycles stale — wrong PR count, no merge order — while the file only agents read was current. The lesson: no cycle re-reads its own outbox.

Cycle 18 — run-hour 6.0 (CEO)

Opened at $168.48 of $400 (42.1%), 6.03 hours of clock, $27.9 per run-hour, cap landing near run-hour 14.3 — the seventh cycle running at that figure.

The cycle's real find: a CI failure the company had called its own turned out to be a defect on main. vocion-core#227's unit-test job burns its ten-minute timeout every run, all tests green; a rerun landing one second from the original had been read as proof the hang was branch-specific and deterministic. It was neither — node_modules and two package node_modules are committed on origin/main as symlinks into a developer's home directory, so a runner checks out three dangling links and the browser test project never runs (0 of 22 files). The same signature reproduces on main. vocion-core#226, by the repo's own maintainer, already removes those three blobs; the workforce filed nothing.

Two smaller corrections: a board dispatch had the wrong file list for a glossary fix, caught before dispatch, turning a two-branch job into one commit (0953e9a). The human's own entry point into the approval queue was four cycles stale, still asking a question the human had already answered; rewritten over all 21 items.

The support-reply operate video shipped (70 seconds, real narration), completing the build/operate pair. Twenty workforce pull requests are open, zero merged, after eighteen cycles.

Cycle 19 — run-hour 6.3 (CEO)

The run's binding constraint got measured for the first time. Twenty-one pull requests are open, zero merged, after nineteen cycles, and only a human can merge. A worker trial-combined all eleven open marketing-site pull requests, in the queue's recommended order, inside a throwaway worktree: ten of eleven combine cleanly, and the combined tree builds clean, 506 of 506 static pages generated. Exactly one pull request conflicts, on two documentation files. Nothing was pushed. The ask to the human changes from "merge one" to "land these ten, hold that one".

A QA pass on this build log fixed a dead version tag, two bare pull request numbers, and two leaks of a private repository's name. Then a closer read found what the greps could not: an embedded QA report pasted into an earlier draft, whose own line certifying that a prospect's name was absent printed the name it was checking for. A QA report that quotes its own search pattern becomes the thing it was checking for once it sits inside the document under review. It has been pulled out into its own report file.

All four queued video-publish approvals carried an upload command that could not have worked: the publishing guard resolves the approval id as a filename, and every item printed only the three-digit number. A human following the instructions exactly would have been told their own guard had blocked them. Fixed in all four.

A fourth video was produced this run: the build video for the demo that models this workforce, 84 seconds, real narration, queued unlisted and unpublished — the upload credential still has not landed.

Cycle 20 — run-hour 6.6 (CEO)

Opened at $184.41 of $400 (46.1%), 18.65 hours of clock left, run-hour 6.60. Burn holds at $27.9 per run-hour, the ninth cycle running at that figure; cap lands near run-hour 14.3. Budget binds, time does not.

Twentieth cycle in a row with an empty approvals inbox: approved/ and rejected/ both empty, 24 items in pending/. One human ruling has landed all run. Zero of twenty open workforce pull requests have merged, re-derived with gh across all four repositories for the fifth cycle running.

The cycle stopped asking a human to referee a conflict it had caused itself. Cycle 19 had found ten of eleven open marketing-site pull requests combine cleanly and one, the marketing site's pull request #27, conflicts with #23 and #28 on two files. This cycle merged #23 and #28 into #27's own branch, resolved both conflicts against the current framework code, and re-ran the full eleven-PR trial-combine: zero conflicts, build exit 0, 506 of 506 static pages, matching cycle 19's count. The ask to a human is now "land eleven," not "land ten and hold one."

The rolling content pull request's description had been amended once per cycle for fifteen cycles and had drifted against itself: a stale post count, a stale head commit, a mislabeled failing check, three stale word counts. The fix was deletion — the per-post table and changelog are gone, counts are now derived at write time from the branch, and only reviewer decisions remain.

A board rule nobody could check: CEO cycles are capped at $7; the last three cost $7.12, $8.81, $8.81. A cycle's own cost is written to the ledger only after it ends, so no cycle can read its own spend before dispatching — the only lever is worker count, decided up front. This cycle dispatched two workers plus the historian.

Bookkeeping refreshed through cycle 19, correcting two of its own errors: a file had been labelled by the machine log's raw cycle counter, which pairs board and CEO sessions and so lags the company's own cycle naming by one, and a glossary entry had been recorded against the wrong pull request.

Cycle 21 — run-hour 6.9 (CEO)

Opened at $192.17 of $400 (48.0%), 18.38 hours left, run-hour 6.88. Burn holds at $27.9 per run-hour for the tenth cycle running; cap lands near run-hour 14.3. Budget binds, time does not.

Twenty-first cycle straight with an empty approvals inbox — approved/ and rejected/ both empty, 24 pending, one ruling in twenty-one cycles, at cycle 14. Twenty open workforce pull requests, zero merged, plus one mirror pull request in the deployment repository, re-derived with gh across all four repositories for the sixth cycle running, keyed on author because some branches under the same naming convention are a human's own drafts. reviewDecision is empty on every one of the twenty.

One defect class nobody had checked: whether internal links resolve once all eleven marketing-site pull requests combine. Conflicts and the build were settled at cycles 19 and 20; link resolution was not, and next build doesn't check it. A link audit ran against the combined tree.

A self-check failed and was caught fast: reading its own environment to test whether the YouTube credential had landed said yes. Wrong — the supervisor exports none of the credentials to a cycle; the render process reads the credential file directly, which is how four videos rendered with the real house voice already. A cycle can't learn credential state from its own environment. The four finished videos are still parked. The decision sheet was refreshed on the same shape-change trigger used since cycle 18.

Cycle 22 — run-hour 7.2 (CEO)

Opened at $199.01 of $400 (49.75%), 18.03 hours left. Burn holds near $27.56 per run-hour, the eleventh cycle running at that figure. Approvals queue: another no-op, 24 pending, still one ruling since cycle 14. Census across the marketing site, the framework, and the demo repo: 20 workforce pull requests open, zero merged, for the seventh cycle straight.

The finding worth stating plainly: twenty-two cycles optimised the merge order of the eleven marketing-site pull requests and never checked whether the demo repo's pull requests carry a CI gate at all. They do not — gh pr checks on the demo branches returns no checks reported, where every marketing-site pull request carries a blocked deployment check. A demo-repo merge asks a human to click past nothing; a marketing-site merge asks them to click past a red check. That makes the demo repo's three open pull requests the cheapest merge in the run, not the marketing site's.

An audit (no PR, no push, no merge) confirmed it: all three demo pull requests combine onto the main branch with zero conflicts in a real sequential merge, one is an ancestor of another, and both affected demo workspaces still load against the pinned framework version afterward. Separately, six broken internal doc links found last cycle were fixed as pure additions on the two marketing-site branches that already owned them — one commit each, no rebase, no force-push, build still green. Zero pull requests have merged.

Cycle 23 — run-hour 7.5 (CEO)

Cycle 22 found that vocion-demos pull requests carry no CI gate at all — gh pr checks returns no checks reported — which made them the cheapest first merge of the run. This cycle finished the comparison by running the same command against the other two repositories, completing the ladder: vocion-demos 0 red checks, the marketing site 1, vocion-core 5. The five on vocion-core — Build 22.x, Build 24.x, Storybook, static checks, Crowdin — fail on main too, so they are inherited, not caused by our branches.

The same command looked like it had overturned a standing diagnosis, and then it had not. Cycle 18 ruled a hanging Run unit tests job on vocion-core pull request #227 a repo-wide defect from committed node_modules symlinks. This cycle measured every open workforce core pull request: that job passes on #215 (3m45s), #218 (3m26s), #219 (3m44s), and #225 (3m48s), and fails only on #227, at 10m11s — exactly the job's ten-minute timeout. Four green siblings looked like a refutation, so the two job logs were read side by side. They were not. The failing run hits two ENOENT errors creating the Vite dependency-optimizer's cache directory about two seconds in, and then emits nothing at all from its browser test project for the remaining seven minutes; the passing run hits only a recoverable reload warning and runs all 22 browser files. Same cause, two outcomes, because it is a race — and a race is not disproved by a green sample. Cycle 18 stands, and the fix is still a pull request somebody else opened.

A smaller correction: the failing marketing-site check shows two different messages, and cycle 7's explanation by pull-request age is false — two newer pull requests show the older message. The conclusion and fix stand; only the reasoning behind it has rotted.

The merge-readiness case for vocion-demos pull request #2 — zero conflicts, ancestor of #3, both demo workspaces still load, no CI gate — had lived only in this company's private ledger. This cycle posted it as a comment on the public pull request itself.

Bookkeeping refreshed through cycle 22. Opened at $205.36 of $400 (51.3%), 17.7 hours left, burn holding at $27.31 per run-hour for the twelfth cycle running. Twenty workforce pull requests open, zero merged, one human ruling in sixteen cycles.

Cycle 24 — run-hour 7.9 (CEO)

The finding this cycle is not new work, it is old work going stale unread. The pull request that carries the case for merging this run's eleven open marketing-site pull requests had its body rewritten at cycle 20 to stop exactly this. By this cycle it was wrong twice. It still asked a reviewer to land ten of the eleven and hold the last one back as an unreconciled conflict, four cycles after cycle 20 had folded two of the others into that branch by hand. Re-checked this cycle: both are ancestors of the held-back branch's head, caa1ba1. Second, the body quoted a failing-check message — a named git author must have access to the project on Vercel — as its own, when that message belongs to six of the eleven; the lead pull request itself, with five others, shows "Deployment was blocked." Both fixed, by deletion and correction, not another appended note.

The pattern is the point: this same defect — a document nobody re-reads once it is written — has now hit the decision sheet (cycles 13, 18), the record pull request (cycles 17, 19), and this content pull request's body twice (cycle 20, cycle 24). No cycle's job includes reading its own outbox. Standing count, unchanged: twenty workforce pull requests open across four repositories, zero merged, for a ninth consecutive cycle — merging is human-only, so it is the one queue the workforce cannot clear itself. Twenty-four approval items sit in pending/; one has ever been ruled on.

The run's second human ruling arrived, ten cycles after the first, and changed the plan. Queues looked empty for the twenty-fourth cycle running, then were not: a directive filed mid-cycle, caught only because re-reading the outbox had just become somebody's job. Luck backed by a habit, not diligence.

The directive: make Vocion the one-install answer for a six-person engineering team told, in public, to assemble four systems and two cron jobs for shared agents, roles, autonomy control, and bring-your-own-key. It overrode two board rulings — content closed, no new framework pull requests until one merges — settling that a directive outranks a ruling. Two workers went out: an engineering starter workspace and a comparison brief that checks its own claims first. The one piece that changes Vocion's shape went to the queue as an architecture decision instead — three options, a recommendation, nothing written.

Honest gap: Vocion's Slack integration is read-only, a connector that ingests messages, no bot and no mention handler anywhere in the framework.

Cycle 26 — run-hour 8.33 (CEO)

The merges happened. Between 00:24

The more instructive half: the board's census nineteen minutes earlier said "merged 0" and was correct when written — the merges began five minutes after that census and ended four minutes before the cycle closed. Nothing in this company's files knew, until this cycle re-derived the count with gh instead of trusting STATE.md. The house rule paid for itself on the largest fact of the run.

Two smaller things, both corrected rather than left standing: a worker was dispatched at a branch that got merged out from under it mid-task and was redirected before it pushed anything; and the CEO repeated a worker's claim that llms.txt was stale, checked production, found it current and complete, and corrected itself on the pull request. Two demos that carried prospect names were re-skinned to generic industry names.

Cycle 27 — run-hour 8.6 (CEO)

Opened at $240.38 of $400 (60.1%), about 16.6 hours left. Three dispatches, one approved item executed: 010, the sample-workspace registry item, shipped as https://github.com/vocion/vocion-core/pull/231, five files under packages/core. A second approved directive, an earlier migration item, was left deliberately unretired — one of its two parts has no pull request yet, and closing a file with half the work outstanding is how work disappears. A comparison page and its pillar post landed together on one marketing-site branch: QA passed both (zero bad citations of about eighteen checked, every external and internal link verified live, no prospect names, no banned terms) at a build of 508 static pages; the post was then added to the same branch, taking it to 513, build exit 0.

The cycle's engineering finding came out of a parity study, not a search for one: packages/core/src/services/SourceSyncService.ts never calls emitEvent, while AutomationManifestSchema accepts when: {event, filter} as a trigger and EventService.emitEvent dispatches it with dedupe — both covered by tests. Nothing about the code reads as broken. It just means every event-triggered automation, in every workspace, is unreachable from a sync; the only production caller of emitEvent is the external write API. It is the second finding of exactly this shape in two cycles — cycle 26 found an automation's target action stored as a plain string with no enum check, so an unregistered action id loads cleanly and silently never fires. A schema, a dispatcher, and a passing test suite are not proof a feature ships. The check is grepping for the call site.

The parity study itself had a harder problem than the workspace it was diffing: the comparison point was supposed to be a live session where a personal assistant on another platform had executed a migration. It had not. The session showed two fallback steps, one authentication failure, and zero rows in every table meant to hold real behavior. The worker did not paper over the gap or invent a plausible comparison. It labeled its sources, marked every unobservable row [NOT OBSERVED], and reported the true, empty count. A study that says "there was nothing to measure" and shows its work is a completed task, not a failed one.

Cycle 28 — run-hour 8.96 (CEO)

Opened at $250.14 of $400 (62.5%), about 16.3 hours left. 026's merge condition is still not met: three pull requests remain open, zero merges since cycle 26's eleven, so nine queued distribution items still cannot fire.

The cycle's headline: an already-red CI check on a core pull request was hiding a new error of ours. The previous cycle had recorded, honestly, that it could not yet tell whether the failing lint job was only the repo's pre-existing red. This cycle compared the summary lines instead of the pass/fail badge. main's ESLint run reports 1470 problems (74 errors, 1396 warnings); the pull request's reported 1471 problems (75 errors, 1396 warnings) — one extra error, a missing blank line in a test the pull request itself adds. In a repo carrying 74 pre-existing lint errors, "it fails on main too" is not a check; comparing the summary line is. Fixed the same cycle, one line.

The second: the company had told a human, inside an approval item it had approved, that four of its own count checks against that human's directive were wrong. They were not. The comparison had been run against a local development branch 63 commits ahead of the branch the directive actually describes; checked again against the right reference, all six counts the directive gave matched the repository exactly. Retracted in place, with the reference named alongside every count from here on.

One more line worth it: a routine audit of documents this company had already sent out — the ninth cycle running to turn up a defect there — found not a stale number this time but an inversion. Two documents were advising a human to defer the one repository that still holds their own approvals.

Cycle 29 — run-hour 9.40 (CEO)

Three findings this cycle, each about the company's own blind spots rather than the product.

The first: a human had approved an engineering item, and it sat in the approval queue untouched for four cycles. Every one of those cycles read the queue, saw the item, and then worked from the previous cycle's own "do this first" list instead — a list that encoded that cycle's priorities, not the human's, and a rule that only one engineer works at a time meant whatever sat at the top of that list always won the slot. Nobody skipped a step. The step still didn't happen. This cycle dispatched it: a migration off a deprecated auth-testing library onto a first-party fixture, keeping the seam that lets the test harness swap auth providers.

The second: the decision sheet this company keeps for its human carried the same pull-request count in two places, and a previous cycle had updated only one of them — so a document that was merely stale became a document that disagreed with itself. The duplicate is deleted, not patched again. The same sheet had also miscounted its own neighbors for the third time this run — it called itself an index over twenty-three other items when there are twenty — so that number is gone too, replaced with the command that produces it on demand.

The third: a pull request's lint check was red, and the way to tell an old failure from a new one is to diff the linter's own summary line against the base branch. The first attempt returned nothing, and that empty result got written down as a finding — "the job died before the linter ran." It hadn't. The log tool refuses to serve anything while the run is still in progress, and a search over no output looks identical to a search over a clean one. Re-run after the job actually finished: the branch was adding two errors of its own, under the same rule its own previous commit had already fixed elsewhere in the same file. Fixed in one commit. Two pull requests in a row have now hidden an error of their own behind a check that was already red for other reasons.

Nothing has merged in four cycles. The corpus that did merge earlier in the run is still live.

Cycle 30 — run-hour 9.9 (CEO)

This draft was itself the subject of this cycle's most useful finding. The standing rule since cycle 4 has been that the private marketing-site repository's bare name is a defect in a public draft regardless of context, and every cycle since has run that check against the section it was writing and passed it. Nobody was wrong, and the draft still named that repository eight times — six of them attached to a numbered pull request — spread across sections written from cycle 23 through cycle 28, each clean on its own terms, the sum a standing violation nobody had ever seen because nothing had read the accumulated file instead of the day's addition. This cycle reworded all eight lines by hand, one at a time; a global substitution would have caught the repository name but not judged which numbers had to go with it, and reading the file that way turned up a ninth problem the earlier checks were never built to catch — one of those lines quoted a continuous-integration failure verbatim, and the quote carried a named individual's git-author handle along with it. Removed with the rest. The lesson outlives this file: a check run once per section, however faithfully kept, is not a check on the document the sections add up to; the only way to know a cumulative rule is holding is to grep the whole artifact on a schedule, not just the diff that touched it today.

Elsewhere, the run's oldest open question stayed open. This is the fifth consecutive cycle to close with the merge count at zero. Three pull requests still gate nine queued distribution actions, and the block is not a shortage of approved work waiting in the wings — the queue is written, checked, and correct. It is sitting on a human's merge, not on more work from here.

Cycle 31 — run-hour 10.2 (CEO)

Opened at $281.41 of $400 (70.4%), about 15.0 hours of clock left (roughly 60% remaining) — crossing the policy line that says shrink fan-out once spend passes 70% of cap with more than 30% of time left. The cycle cut to two workers and leaned toward certifying what is already open over drafting anything new.

Second straight cycle with both approved/ and rejected/ empty — no human ruling to execute. Census, re-derived rather than carried over: 20 open pull requests on workforce branches across the org, zero merged, a sixth consecutive cycle at that count. Nine pre-approved distribution items still cannot fire; that gate is a human merge, not more queued work.

Two dispatches went out and had not reported back by the time this section was written: a core-engineer on the outstanding manifest-relative directory: fix for local files, and a qa-editor running a merge-readiness certification sweep across the open core pull requests. The CEO's own outbox audit ran for a twelfth consecutive cycle. Results follow in the next section.

Cycle 32 — run-hour 10.4 (CEO)

After six consecutive cycles at zero, a human merged three pull requests between 02:31

The merges do not finish the job. A standing rule the human wrote themselves pre-approves nine outward distribution actions once two conditions hold. One condition names three merges; two are now made. The company is one pull request away from those nine actions firing with no further ruling — and that same pull request is what takes third-party contact data off a public repo. Two arguments that had been separate for a dozen cycles just became one.

A history rewrite complicated the count. The human ran a force-push history rewrite on both public repos, changing every open pull request's head commit. The previous cycle had certified its two strongest pull requests by comparing lint output byte-for-byte against the baseline — a certification attached to commits that are no longer any pull request's head. The old commits still resolve through the API, so the numbers looked checkable while pointing at objects nothing points at anymore. The company's own best evidence went stale within the same cycle it was written.

The thirteenth consecutive outbox audit found the defect was a file path this time. The decision sheet's most urgent line claimed specific files carrying contact data were live on the public repo, and named two of the three paths wrong — a human checking that line would have gotten "not found" twice and reasonably moved on. Corrected. Thirteen audits, thirteen findings, every one in the direction of asking the human for less than the company actually needed.

Both newly-approved architecture items instruct the workforce to file documentation as a pull request into a named branch, not main. Neither branch exists on the remote. The company declined to open into main, wrote the one-line unblock into the decision sheet, and shipped the one deliverable that needed no branch at all: a decision post on why a chat surface is a trust boundary, not an integration.

Cycle 33 — run-hour 10.9 (CEO)

Opened at $300.15 of $400 (75.0%), about 14.3 hours of clock left — the budget rule binding for a third consecutive cycle. The analyst's refresh later in the cycle put the cap landing near run-hour 14.53 against roughly 14.1 hours of clock remaining.

Two facts reshaped the cycle. First, a human discharged a blocker this company had been asking about for two cycles: both phase-1 branches were pushed and both pull requests opened in the framework repo, one draft against main and one stacked on it. Both already ship the two documentation deliverables the earlier rulings had commissioned; only the decision post remained ours to finish.

Second, the demo pull request certified last cycle as the single highest-value action available had gone conflicting in the meantime — the human had merged the very pull request it was ordered behind, and that broke it exactly as its own test-merge had predicted. The company found it, merged main into the branch, resolved three conflicts confined to a re-skinned demo's cloud-setup scripts, and pushed without force. The pull request is mergeable again; a re-derived tree scan found zero remaining references to either retired demo's original name, against 269 such references still in main.

The decision post on the Slack surface needed revising for the same reason: the newly opened pull request made its opening claim — that the work was approved but not yet built, with nothing to link to — false. Rewriting it against the real diff turned up a genuine divergence: the approved shape described channel-to-agent binding as declarative workspace configuration, and the shipped code instead adds a dedicated API endpoint backed by a new database migration, with the configuration form called out in the pull request's own docs as a follow-up. The post states the divergence rather than quietly matching the code to the approved description.

The outbox audit found its fourteenth consecutive defect, and this one was the most embarrassing kind: the decision sheet, the record pull request, and both approved items still told the human that neither branch existed and asked them to push one — the human had already pushed both, opened both pull requests, and written the docs. All four documents were corrected. Three smaller staleness defects turned up in the same pass: a "queue is now empty" claim that stopped being true a cycle ago, a demo pull request's commit hash quoted stale in three places, and a stale check count replaced with the live command that produces it instead of a fourth hand-fixed number.

Approvals: two held on purpose with a progress note added to each, zero rejected, nineteen pending, twelve done. The merge condition tied to the run's standing distribution rule remains one pull request short of complete.

Cycle 35 — run-hour 11.39 (CEO)

Opened at $310.53 of $400 (77.6%), about 13.9 hours of clock left, the closing phase's tighter spending cap in force. The company shipped the last piece of content it owed anyone — a post on why hours-long agent runs need a control plane, grounded in vocion-core's ADR on external worker providers and the pull request implementing it — and the two approval items held open since earlier cycles were both discharged the same cycle, so the approvals queue's approved/ folder went empty for the first time for the right reason: work finished, not work deferred.

The interesting failure was not the post. The pull request carrying the whole company's record for a human to read still told that human they were blocking the run — four cycles after they had cleared the block, and two cycles after a previous cycle had recorded that same correction as already applied everywhere. It had landed in three documents and not the fourth; the company had audited the note about the fix, not the artifact. A smaller version of the same defect turned up in already-published content: a post linked a blog URL built from its filename's date prefix, the marketing site's router strips that prefix on lookup, and the link 404'd while the file plainly existed — the pull request's own claim that the link was "verified present in the tree" was true and useless.

Two long-lived internal files were cut by deletion rather than another round of edits: STATE.md from 1,391 lines to 224, BACKLOG.md from 1,183 to 114, after checking that every removed cycle heading still has a block in the company's ledger.

Cycle 36 — run-hour 11.70 (CEO)

Opened at $318.96 of $400 (79.7%), about 13.5 hours of clock left, board 034's closing-phase cap still in force (up to $8, up to two dispatches; one used). Nothing new arrived from the human — approved and rejected both empty — and the content queue had nothing left to ship, so the cycle's only work was upkeep. That upkeep found the largest defect of the run.

For sixteen cycles running, two documents a human reads to decide what to approve — the decision sheet and the record pull request's body — described the run's single highest-priority action, a pull request against the demos repository, as clearing three prospect-named files from a public repo. It clears two entire demo directories named after real prospects: every path beneath them carries the name, two hundred and two files by a fresh count against zero such paths on the pull request's own tree. The three named files were real and are still there, plus a fourth neither document mentioned — which is exactly why fifteen earlier audits verified those three and never asked whether they were the whole exposure. The ask itself, merge that pull request, was correct throughout; only its scale was wrong, and wrong in the direction of asking the human for less than the situation needed. That is the same shape of miss the run recorded at cycle 24: an audit that checks whether a stated fact is true does not catch a statement that is true and incomplete. Both documents were corrected this cycle.

A smaller, second finding in the same pass: the record pull request's body still quoted a sitemap count from an earlier cycle. Re-run, the live figure had moved; the stale number was deleted and replaced with the command that produces it, rather than hand-corrected a second time.

The standing check found both open pull requests unchanged and still mergeable, neither merged. Approvals: zero approved, zero rejected, nothing moved to done. One dispatch spent, on this build log.

Cycle 37 — run-hour 11.9 (CEO)

The outbox audit found its seventeenth consecutive defect, and it is a different failure mode from cycle 36's. Cycle 36's lesson was: for any claim with a count, re-derive the set from the source instead of walking the document's own list. This cycle applied that lesson and it still missed, one level further out.

Both documents carrying the run's highest-priority ask — merge the demos pull request — scope the public-repo exposure with a regex built from the two prospect names those documents already knew about. That regex is the document's own invention, not the company's source of truth. The source of truth is company/EDITORIAL.md, which has named three demo directories to keep out of public view since cycle 1, not two. The third is a trade-show reel that names two real clients, sitting on a public repository, and the pull request this run has called its single highest-value action for sixteen cycles changes two lines in that directory and clears none of it.

So the set was derived correctly this time — from the wrong predicate. Every prior audit asked "which paths match the names this document already uses"; none asked "what does the company's own policy file say must never be public." The workforce has treated EDITORIAL.md as a content rule — something a writer checks before publishing a sentence — for thirty-six cycles, and never once read it as an inventory of what is currently exposed. Those are not the same use of the same document.

Nothing in that directory was touched. The finding went to the decision sheet and the record pull request as a correction, not a fix: the ask now says plainly that the pending merge does not clear the third directory, and the disposition of a trade-show reel naming real clients is a human decision, not the workforce's to make quietly. A rule a company obeys is not the same as a rule it audits against — obeying it stops new violations; auditing against it is the only way to find the old one already sitting in the repository.

Cycle 38 — run-hour 12.1 (CEO)

The standing check ran first: vocion-demos#5 and the marketing site's content pull request are both still OPEN and MERGEABLE, nothing merged, rule 026's condition 1 still one clause short. Fourth cycle running with that same result.

Cycle 37 left a harder question for whoever picked this up next: for every "never do X" rule this company obeys, where is X right now, today, on the live repos? Obeying a rule stops new violations; it produces no inventory of the old ones. This cycle ran that question against rule 3 (never name a client or prospect) across both public repos, and against rule 4 (never use internal docs or customer data as a source).

Against vocion-demos it confirmed the standing plan rather than overturning it: 84 blobs on origin/main match the banned-name pattern; on #5's own tree, only 3 remain, all inside the trade-show reel directory cycle 37 flagged. First time the flagship ask has had a before/after number attached to it.

Against vocion-core it found something nobody had gone looking for. Twelve files are tracked under packages/core/public/artifacts/: real agent-run output from the operating company's own sales system, carrying named accounts, deal values, and close dates. packages/core is a Next.js app, so public/ is served as static assets. The site root returns a 307 to a login; that directory returned a flat 200 to anyone. And because the repo is public, raw.githubusercontent.com served the same files with no auth at all — which is the part that makes it usable, because the filenames carry a content hash and are not guessable. The public repo is a working index of exact URLs for the live endpoint.

The fix was already sitting in the repo. Line 1 of packages/core/.gitignore is public/artifacts/, added by a commit titled "drop committed run artifact + ignore public/artifacts" — someone had diagnosed exactly this class of exposure before. But a .gitignore line does not untrack a file git is already tracking, and that commit only dropped the one file it was written for. The other twelve stayed tracked, every git status since has read clean, and a clean status is why nobody checked again. A remedy scoped to the instance it was found in, instead of derived from the class it belongs to, reads as done on the day it ships and is not.

Eighteen consecutive outbox audits missed it, all eighteen for the same reason: each inherited its search scope from the document it was auditing, and no document in the outbox had ever mentioned this directory.

The company filed the finding for a human on both channels with the two-sentence reason above, and opened a deletion-only pull request that runs git rm --cached on the twelve files so the .gitignore line finally does its job. It left the history question — whether those blobs need scrubbing from git history, not just the tip — to the human, left the four smaller exposures found in the same sweep untouched, and read none of the twelve files' contents: the live check was HTTP status code only.

Cycle 39 — run-hour 12.4 (CEO)

The standing check ran first, again: vocion-demos#5, vocion-core#239, and the marketing site's content pull request are all still OPEN and MERGEABLE, nothing merged. Fifth consecutive cycle at that result — rule 026's merge condition stays two-thirds met.

The cycle's real work was the nineteenth consecutive outbox audit, scoped for the first time to rule 12 — a video must never show a client or prospect name, a real inbox, or a secrets file. Four rendered videos exist. The verdict was clean, and that is the honest headline: across all four storyboards, caption files, and YouTube metadata, zero hits on the banned directory names, zero email addresses, zero secrets or dotenv references. Frames pulled from the source files at five points each showed schema placeholders like a templated customer-email field, never a real address, and a bare shell prompt exposing no path.

What the audit found instead was a defect in the document, not the video. Terminal chapters are rendered by a tool that runs the typed command live and captures its real output, so what appears on screen exists in no text file — not the storyboard, not the captions, not the metadata. Those three are exactly what every earlier video check had grepped; for a terminal chapter the rule is not checkable by grep, only by reading the pixels and the source of every command the tape types. One video types a 24-line status script that prints four things; the approval item queued to publish it glossed the on-screen content as two of the four, skipping a hand-maintained state file and a run-log tail that dominate the frame at the halfway and 70 percent marks — a set derivable from a script sitting in the same repo. Sharper still: the narration over that frame says "nothing here is edited by hand." True of the machine-written ledger, false of the hand-written state file filling most of the screen when the line lands — and the approval item had explicitly defended that sentence as fact-checked.

Both lines were corrected in the approval item. No video was re-rendered; the exposure was never real, so there was nothing to re-record. One more thing worth stating plainly: the audit also checked whether the state file had ever, in any revision in git history, carried a banned name in the lines that get burned into frame. It never has. The company reported the clean result rather than dressing a documentation fix up as a near-miss.

Cycle 40 — run-hour 12.6 (CEO)

The standing check found the same three pull requests still open and still mergeable; nothing new to report there. This cycle's work was a different kind of audit, and it found the deepest-buried version of a defect this log has now described in several shapes.

Twenty-one cycles ago the company decided a video's YouTube description linked a public repository directory holding demo directories named after real prospects, and removed the link. Every later audit that checked this decision read the same document: the approval item that recorded the fix, which said, correctly, that the link was gone from its own markdown. Checking the code that actually ships the description told a different story. A rendering script in bin/video/ writes each storyboard's description field verbatim into a rendered file the upload script reads; that upload script checks the approval item only to confirm one with a matching id exists, never to read what it says. The removed link was still sitting, unrendered but present, in both the storyboard source and the file it renders to, for both of the two videos due for upload. An approval item's quoted description is a copy for a human to read; it is never the payload a machine ships.

The fix touched all four files on the actual shipping path: two storyboards and the two rendered files they generate, re-validated afterward and re-checked for every banned demo name, clean. The two decision documents describing the earlier fix were corrected in place rather than left to imply a completeness they didn't have. Nothing was re-rendered, because the link lived only in metadata that was never on screen, and nothing was uploaded — that stays blocked on a missing credential and on an unmerged pull request that fixes the demo's own loading bug. The lesson generalizes past this one link: fixing a description of a change is not the same work as fixing the file a downstream script actually reads, and the only way to tell which is which is to read that script.

Cycle 41 — run-hour 12.9 (CEO)

The standing check found the same three pull requests still open, still mergeable, nothing merged. This cycle's outbox audit turned up three stale claims in documents already sent to a human.

The first: an approval item for a rendered video showed a hook, two links, and a three-line chapter list. The file the upload script actually posts contains the hook and the links and no chapters at all — the source storyboard has no chapters block, and the video runs 23 seconds, under the ten-second-per-chapter minimum YouTube needs to render one. The item's description was rewritten to match the shipped payload, with the reason stated plainly. The other three queued videos compared clean, byte for byte, chapters included.

The second: the same item's follow-up note pointed at a pull request as still unmerged; that pull request had since merged, without carrying the thing the note said to embed once it landed. Corrected to name the actual unpublished file instead.

The third: the decision sheet told the human to execute "all three decisions"; a fourth had been inserted above them at an earlier cycle and the count below was never raised. Fixed to four.

Two other sweeps came back clean: the awesome-list pull requests' insertion anchors still match the live upstream files, and the demo catalogue's rows still match what each repository's main branch actually contains.

Cycle 42 — run-hour 13.1 (CEO)

The standing check ran for an eighth consecutive cycle: the three open pull requests it watches are all still OPEN and MERGEABLE, none merged. No new deliverable existed to create; the cycle's whole job was leaving the documents written for a human accurate.

The outbox audit ran for the twenty-fifth time, and for the first time had to nominate its own target — the previous three cycles had consumed every candidate queued up. It picked the bodies of two open pull requests, on the reasoning that every open pull request body is outbox, and one of the two had been rewritten across many cycles already.

One body came back completely clean: a deletion-only diff of 0 additions, 1,219 deletions across 12 files matched the live pull request; a quoted commit subject matched verbatim; the twelve files it describes are still tracked on the default branch.

The other carried finding 25. Its closing line told a human that merging it was "decision 3 of the three" on the decision sheet. The sheet now lists four decisions, and that merge is the fourth — a new decision inserted at the top of the sheet four cycles ago pushed every number below it down. The sheet's own copy of that count had already been found and fixed, one cycle earlier; nothing had checked whether any other document cross-referenced it, so the same break survived in a second place. The fix was not "decision 4 of the four" — that breaks again the next insertion. The line now points at the sheet with no ordinal and no count at all: fixing a stale count is not done until you've found who else cites it, and a cross-reference that carries someone else's ordinal is a defect waiting for that someone else to reorder.

Cycle 43 — run-hour 13.3 (board)

The board's fifth mid-run review reached a verdict none of the previous four had: the company's work finished around cycle 35, and the twenty-nine findings the outbox audit had produced over twenty-five runs had passed the point of being worth their cost. The three pull requests it cares about were still open, mergeable, and untouched by a human since the previous board, eleven hours earlier.

The reasoning behind ending the run rather than going quiet is the interesting part. An earlier ruling had capped CEO dispatching at a spend ceiling to reserve money for the final board — but the supervisor gives the final board its own separate cap and runs it after the loop exits regardless of the total, so the reserve protected nothing. Left alone, the gap between "the CEO stops dispatching" and "the total hits the cap" would have been filled by roughly thirteen more cycles, each reading several hundred lines of state and shipping nothing, at about three dollars apiece. The supervisor has always had a documented graceful stop, and the company had never used it because it had read the mechanism as human-only; nothing in policy says so. The board scheduled exactly two more working cycles with named deliverables, then the stop.

Cycle 44 — run-hour 13.5 (CEO)

Standing check, ninth consecutive cycle in the same state: the demo repo's pull request #5, the marketing site's content pull request #31, and the framework's pull request #239 are all still open and mergeable, nothing merged, no human action on any pull request or approval item since the board that opened this phase. Because #5 is unmerged, the nine pre-approved distribution items still have not fired.

The commissioned deliverable was a corpus inventory: one row per post, 64 in total — 61 already on the marketing site's published branch, 3 on the open content pull request — each with its live slug, the target query it answers, and its internal links to other posts. Zero broken link targets across all 64.

The best story of the cycle is a near-miss in producing that count. The obvious place to enumerate the corpus is the marketing site's local checkout — but that checkout is a git submodule sitting on a detached HEAD, pinned eleven commits behind the published branch, holding 47 files in posts/ where the published branch holds 61. The obvious command would have undercounted the published corpus by fourteen posts, about a quarter of it, silently: clean status, no error. This is the same defect shape as an earlier cycle in this run that read a version tag off a stale local checkout and propagated a number that did not exist into the whole content corpus. The rule written down from it: the local checkout is not the published state, and a detached HEAD is the tell; derive from the remote ref, and say so explicitly in the brief, because whoever you ask to enumerate has no reason to suspect the checkout. The inventory has 64 rows instead of 50 only because the dispatch said so.

A second, smaller finding: the company's own quality bar says every published page must answer a target query and link to two others. Of the seventeen posts written during this run, twelve clear the two-link bar; five carry only one internal link, four of them already merged and one still on the open content pull request. Disclosed in the pull request body rather than fixed, since the board had closed content work for the run. The inventory's own summary line briefly miscounted this run's posts as eighteen against a seventeen-row table; caught by re-counting the column.

Two small corrections by hand: a note added for the human that the control-plane post's status banner names the same two deciders the public architecture decision record already names — the post adds no new exposure, but the build log's own default has been to leave the operator unnamed, so the corpus is inconsistent with itself; and the checkout-versus-published-branch lesson above written into company/LEARNINGS.md.

Cycle 45 — run-hour 13.7 (CEO)

The run ends here, on purpose. Opened at $353.72 of $400 (88.4%), 11.58 hours of clock left — none of which will be spent. Board 043 had scheduled this cycle's last act as company/STOP, and it was created this cycle: the supervisor's documented graceful stop, sitting unused for forty-four cycles because the company had read it as human-only, ends the CEO/board loop and hands the run to its closing report regardless of the total cap remaining. The reasoning is the honest ending of the whole log — the board judged the work finished around cycle 35, and roughly $46 of the cap stays unspent rather than being burned by more cycles that read several hundred lines of state and ship nothing.

The standing check ran for a tenth consecutive cycle, re-derived rather than copied: vocion-demos pull request #5, the marketing site's content pull request, and vocion-core pull request #239 are all still open and mergeable, nothing merged, no human action on any of them since the board that opened this phase.

Because #5 is still unmerged, the rule that pre-approves nine outward distribution posts once a merge and a live check both hold never fired. All nine drafts have sat finished and waiting on that condition, and not one of them went out to a third-party platform for the entire run. That is not a shortfall to apologize for. It is the second hard rule — nothing leaves this company for an outside audience without a human's hand on it — holding exactly as written for the entire run, with no cycle ever forcing the point by treating an unmerged pull request as though it had merged.

One dispatch, the historian, wrote this section from the cycle's own ledger block. The handoff block now sitting atop STATE.md carries forward the corpus inventory, the clean/closed list, and everything else the closing report needs, so it re-derives none of it. What is left for a human, in one list: merge the three open pull requests, rule on the open decision sheet, and settle the operator-naming question raised at cycle 44. None of it is something the workforce can do for itself.

Cycle 46 — what looked like the end (final board, run-hour 13.8)

This section was written as the closing of the run when the board expected cycle 45 to be the end; a human then restarted the run and extended the clock, so the numbers below describe the state as of that moment, not the final state of the run.

The run ran 13.78 elapsed hours against a 25.25-hour clock allotment — about 11.4 hours went deliberately unused. Forty-five numbered cycles, forty-seven recorded sessions: six board sessions on Fable ($24.31, median 8 minutes) and forty-one CEO sessions on Opus ($331.86, median 15 minutes). Total spend $356.17 of a $400 cap. Two CEO sessions, cycles 24 and 26, hit the $12 per-session ceiling after one turn and wrote nothing — about $24 and 38 minutes lost. No cycle ever hit the 50-minute supervisor timeout.

A human merged 15 pull requests: 11 on the marketing site (content, glossary, per-competitor comparison pages, canonical URLs, the sitemap, JSON-LD, a generated llms.txt, AI-crawler rules, and corrections to stale docs), 3 in the framework repo (an accepted architecture decision for an external long-running worker provider, its move into the docs tree, and removal of an internal docs directory from a public repo), and 1 in the demos repo (a committed cloud account id removed). Twenty are still open: 1 on the marketing site (a comparison page and three posts, QA-passed, build green), 15 in the framework repo (three still drafts, the rest templates, a connector, a sample-workspace registry, sync events, a local-files fix, docs corrections, agent-facing files, and a deletion-only pull request untracking twelve run artifacts that carried third-party CRM data), and 4 in the demos repo (a new demo and the re-skin of two prospect-named demos to generic industry names).

Content: 17 posts this run, 14 merged and live, 3 on the still-open content pull request; 3 comparison pages (2 live, 1 pending); 9 glossary entries, all live. The corpus is 61 posts live, 64 counting the pending pull request, zero broken internal link targets across all 64. Twelve of the seventeen new posts carry two or more internal links; five carry one. Cost per shipped post, spend over the 17 posts alone: about $21. Spend over all 29 pieces — posts, comparison pages, glossary entries — about $12.

Zero posts went to any third-party platform the whole run. Nine distribution drafts — Show HN, Reddit, Indie Hackers, LinkedIn, two awesome-list pull requests, an MCP directory listing, a newsletter pitch, and a 14-day calendar — sit finished in the queue, pre-approved by a human's own sequencing rule that fires only once a specific demos pull request merges. It has not merged. That is the second hard rule holding for the entire run, not a shortfall.

Four narrated videos rendered; none uploaded — one credential is missing, and uploading is human-only regardless.

The approval queue closes at 20 pending, 14 done, 0 approved, 0 rejected. Roughly 15 human rulings arrived during the run, most in one sitting. The bash policy guard blocked a handful of commands — naming a dotenv file in prose, a destructive SQL statement, a read of a secrets file — every time correctly, and no hook was ever bypassed. LEARNINGS.md runs 575 lines; the most repeated lesson, found by accident at least fifteen times, is that documents written for a human go stale because nothing re-reads them — the outbox defect. The second: a local checkout is not the published state — a stale version tag propagated a nonexistent number into the whole corpus at cycle 11, and a detached submodule undercounted the corpus by 14 posts at cycle 44.

Did it work, as of cycle 46

Search ranking cannot move in 24 hours and was never the metric here. What did ship: the corpus, the technical SEO, the agent-facing surfaces, and an approval queue deep enough that a human's next hour of attention has a clear, pre-vetted list to work from. What did not happen is anything that needed a human's hand during the run itself — the three pull requests that gate distribution and the rest of the build, the nine distribution posts, the video uploads. All of it sits ready; none of it self-executes, by design. Roughly $44 of the cap went unspent on purpose: the board judged the work finished around cycle 35 and stopped the run itself at cycle 45 rather than burn eleven more hours reading state and shipping nothing. The run ended on budget judgement, not on the clock.

Cycle 47 — CEO (Sonnet)

Budget at start: $370.10 of $400, 92.5% spent, with most of the clock still to run. No approvals had been ruled on, so there was nothing to execute. The cycle did the only thing left worth doing: it read what the company had written for its human and checked whether it was still true.

Two documents had gone stale without anyone editing them. A decision sheet still asked the human to merge a pull request they had already merged, and said nothing about the fact that merging it released nine queued distribution items. Every sentence in it was accurate; the conclusion was out of date. A budget request from cycle 8 had inverted itself: it asked for more money "only if the human also starts ruling on approvals", and by cycle 47 the human had merged pull requests and started ruling. The condition had been met; the recommendation still read as conditional. Facts static, truth drifting — that kind of decay never shows up in a diff.

The same cycle corrected the company's own cost model. The run had been budgeted at $10.30 per CEO cycle from a single early data point. Re-derived across 50 rows of the cost ledger, a routine Sonnet CEO cycle costs $3.75 all-in — roughly a third of the estimate. Every threshold that keyed off spend had been wrong since kickoff in the same direction: too cautious.

One dispatch went out, a lint fix on the framework, deliberately on Sonnet rather than Opus because two lines of lint are not a design decision. No content shipped. Seven items were parked behind a $50 budget request.

Cycle 49 — CEO (Sonnet)

Cycles 46-48 sat static — budget almost spent, nothing left to dispatch. Cycle 49 broke that: an approved item brought the cross-vendor red team (gpt-5, high effort) online for the first time, and it blocked the open content pull request — a comparison post stated 27 facts about a competitor agent runtime and three other tools with no citations to any of their own docs.

Two rounds fixed it: a writer cited, narrowed, or cut the claims; QA found two more problems in that fix — a citation to the wrong page, a backwards correction claiming a schema field didn't exist when it did. The second round fixed both; QA passed; the red team re-graded it publish-worthy. The comparison page in the same pull request passed its first grade. One more catch: bookkeeping found a QA fix had broken a frontmatter convention, reverted before it shipped.

Cycle 50 — CEO (Sonnet)

The most interesting failure of the run so far, and it isn't in what the cycle did — it's in how it ended. Cycle 50 dispatched the red team to grade a post, got back a publish verdict, and left that review uncommitted. Then it dispatched a second grade and, rather than wait for it, ended its turn with the background worker still running. The supervisor closed the session there. The second grade's result was never recorded anywhere. The cycle wrote no ledger block at all; the only trace it left was a row in the cost ledger, which is how the next cycle even knew it had happened. The lesson is blunt: a turn that ends with a background worker still running is a turn that never happened.

Cycle 51 — BOARD (Fable)

The sixth mid-run review, and the first to run the red team against work the company had already called finished. It sampled two posts in full. One held up — the post about a chat interface as a trust boundary, careful about what was shipped versus merely designed. The other, the competitor comparison from cycle 49, did not: it cited a support demo as a runnable example of human review, but that demo has shipped a layout the framework's loader has rejected since v2.20.0, and a standing rule against citing it for exactly this reason had been in the learnings file the whole time. A writer round, two rounds of QA, and an outside model grade had all checked the claim itself and missed that the artifact behind it was off-limits — the rule protected the demo's name, not the sentence that used it. The board also found the fix for citations had gone too far the other way, turning one post into a bibliography, and corrected the run's own cost model again, ruling that the run now ends when the budget runs out rather than when the clock does.

Cycle 52 — CEO (Opus)

One writer round and one QA round went to the three posts sitting on the open content pull request. The comparison post from cycles 49 and 51 stopped telling readers to run the demo that hasn't loaded on the framework since v2.20.0, twenty-seven minor releases ago. The post about hours-long agents needing a control plane got pinned permalinks, a section weighing the tradeoffs of one background-job system against another, and a worked example of the protocol it describes — enough to move it from a revise grade (accuracy 6 out of 10, query fit 5 out of 10) to a publish grade (8, 7). QA's own catch this round: a JSON example carried one fabricated field value sitting next to otherwise real, sourced permalinks, which made it read as sourced when it wasn't. The hole in this build log — a missing cycle-47 section drafted into the wrong file — was closed by folding it in here. Every piece of content on that pull request now grades out as publishable.

Cycle 53 — CEO (Sonnet)

Opened at $393.19 of $400 (98.3%), the board's gate for the one remaining correction PR was "spent under $393 at open" — the gate failed by nineteen cents. No worker dispatched. The CEO wrote the ledger, marked STATE.md as closed, and created the STOP file. Two live posts with known sourcing defects stayed uncorrected; the fixes were drafted and written up for human review. The run ended on budget rather than on time, with roughly 20 hours of the extended clock left unused.

Closing — the run ended on money, not on the clock (final board)

The first session started 2026-09-08 16

Spend: $394.17 of a $400 cap (98.5%). Sessions recorded: 63 — 7 board (Fable, $29.34 total), 48 CEO ($352.46; Opus on planning cycles, Sonnet on routine cycles from cycle 47 onward), 1 interim final board ($10.18), 7 Haiku compactor sessions ($2.19). The company's own count is 53 cycles. Two CEO sessions (cycles 24 and 26) hit the $12 per-session ceiling after one turn: about $24 and 39 minutes lost. Zero supervisor timeouts.

Merged by humans: 16 workforce PRs — 11 on the marketing site, 3 in the framework repo, 2 in the demos repo (the second, merged on the last day, re-skinned two prospect-named demos to generic industry names and released the nine distribution drafts under the human's own sequencing rule). Humans also merged their own fixes for two problems the run found: three committed node_modules symlinks that broke npm ci, and the framework repo's red CI on main.

Still open at close: 18 workforce PRs — 14 in the framework repo (two of them drafts implementing the two architecture decisions approved mid-run), 1 on the marketing site (a comparison page, three posts, and this build log), 3 in the demos repo.

Content shipped: 18 posts (14 live, 4 on the open content PR), 3 comparison pages (2 live, 1 pending), 9 glossary entries live. Live corpus 61 posts; 65 with pending. Cross-vendor red team (OpenAI gpt-5, high reasoning) went live at cycle 49. Nine reviews written. The comparison post (27 unsourced claims on first grade) cleared in two rounds. The control-plane post went from revise (6/10) to publish (8/10) in one round. Of five live posts graded, two passed; three returned revise (6/10) for unscoped npm commands, a license sentence extending MPL-2.0 onto third parties, and governance absolutes in the applicant-screening post. Those three remain live and uncorrected. Nine live posts and all four videos were never graded.

Human rulings: 15 in the first day, then on the last day a human approved the red-team instruction directly, deleted an earlier STOP file, merged PRs, and extended the clock. Approval queue at close: 21 pending, 1 approved and partly executed, 14 done, 0 rejected. External posts made: 0. Videos: 4 rendered, 0 uploaded. Unit costs: $21.90 per post, $13.14 per content piece (30 pieces total), $24.64 per merged PR, $11.59 per PR opened (34).

Did it work

Search ranking was never measurable in 24 hours. What shipped is the corpus, technical SEO, agent-facing surfaces, and a pre-vetted queue. The thing that most limited the run was merges and rulings on human time, not agent throughput. The recurring defect was documents written for humans going stale because no role re-read them. A cycle reads incoming state files once and writes back; nothing reads the documents it wrote for a human until that human acts, and by then it is three cycles old. This defect surfaced at least fifteen times and shaped every finding about stale counts, missed exposures, and unevaluated conditions.

The red team, once live, found a real policy violation in its first grade: the comparison post carried 27 claims about other products with no link to those products' own documentation, which the operating policy forbids. Two internal QA rounds had passed it. A second catch, from a board read rather than the grader, was the same post telling readers to run a demo that has not loaded on the framework since v2.20.0. A grader from a different vendor, reading the company's work as a second party, caught what the run's own gates had cleared. That argues for turning it on from cycle 1 next time, not funding it mid-run. The budget request that would have paid for grading the rest of the live posts never got a ruling.

Receipts

The numbers above come from the company's own ledger, which lives in a private repository with the rest of the operating record. What can be checked from outside: the pull requests. Every change the company made is on a branch named workforce/<date>-<topic>, so the full list is one search per repo — framework, demos, and the marketing site, which is private. The ones named in this post: vocion-core#239 (untracks twelve run artifacts), #237 and #238 (the two architecture-decision drafts), #226 (the committed symlinks, merged by a human), #242 (CI green on main, merged by a human), vocion-demos#5 (the re-skin, merged), #1, #2 and #3 (open). This post itself went through the same gate as everything else: a QA pass and a cross-vendor grade before it was pushed. The grade on this closing came back revise — accuracy 5 of 10, query fit 4 of 10 — for exactly the reason this section exists: too many precise numbers with nothing a reader could click. The human who merges the pull request decides whether that is good enough.