← Journal

Phase 3 closed -- the site finally tells its own history accurately

The honest headline first

Phase 3 was the phase in which this site stopped describing the experiment from the outside and started documenting it from inside — the dated Phase 2 journal entry, the three process diagrams, the Infrastructure / Lab expansion, the homepage status section, and a cleanup and audit pass over the whole site. It ran on the foundation Phase 2 established: a persistent Runner, bounded attempts, independent review, and a checkpoint at the end. What it demonstrated is that the same machinery carries a documentation-and-audit phase as well as a build phase, with no new mechanism attached. What it also recorded is a mis-step the site would rather show than hide: the first Phase 3 work was found to have run from a stale source, and the phase was carried forward from the accepted Phase 2 candidate instead.

3.1 — What Phase 3 did

The delivered Phase 3 tree, in the order it landed, contains: the authored Phase 2 journal entry (sections 2.1 through 2.7, written from the recorded run data rather than reconstructed afterwards); the three Factory process diagrams — the architecture-and-workflow diagram on The Factory, the iteration-lifecycle diagram on Method, and the project-and-phase-lifecycle diagram on Status / Roadmap — each embedded into the page that uses it, with two small layout corrections made against the validated build before they merged; the Infrastructure / Lab expansion with the component overview and the agent-execution and infrastructure-evolution sections; a compact homepage status section stating which phases are complete, which is underway, and why the published site documents the previous complete phase; and a cleanup pass — the starter-template branding and stock wording removed from the site chrome, the template favicon replaced with the Dark Factory mark, and a site-wide audit that found and corrected a stale “Phase 2 in progress” statement left over from the earlier phase.

Deliberately not in it are the lower-priority additions — additional detailed architecture diagrams, extended execution-tool comparisons, detailed infrastructure configuration documentation, advanced visual presentation, and expanded historical reporting. They are deferred to the next phase, per the deferral policy the human review set for Phase 3, not abandoned.

3.2 — The same machinery, a different kind of phase

Three phases, three different shapes of execution, one line of descent:

  • Phase 1 — human-initiated, hosted model. A human initiated each execution with the invocation scripts; the work ran on Claude Code with Sonnet. It proved the scaffold, the theming, the content model, and the deployment pipeline end to end.
  • Phase 2 — persistent Runner, local model. A human-started process became a running one: a persistent Runner coordinated by the Controller, locally hosted Qwen3.8 inference for the project work, and the execution-tooling move from OpenCode to OpenHands behind the adapter. It proved that locally hosted inference operates through the Factory across a full phase.
  • Phase 3 — the same foundation, a documentation phase. The recorded run platform was Runner-orchestrated role work under OpenHands with the locally hosted Qwen3.8 model, served through Radix on the AI PC — the Phase 2 foundation carried forward unchanged. What it demonstrated is that the foundation is not tied to the kind of work it carries: an evidence-honest content-and-audit phase runs on the same dispatch, review, and acceptance machinery as a build phase.

The contrast is the point of the record: the phase that needed the machine most (Phase 2, building the machine) and the phase that only needed to use it (Phase 3, documenting the machine) ran on the same contract. Nothing in Phase 3 required a change to the Factory itself; that is recorded as a finding, not assumed.

3.3 — The stale baseline, and the correction

One thing in the record needs to be stated plainly. Before Phase 3 work was accepted, it was found that the first Phase 3 attempt had been run from a stale source — a tree predating the accepted Phase 2 candidate, one that still carried Phase 1-based material. The accepted Phase 2 tree was restored to the project as the Phase 3 baseline (that is the first pull request in the related set above), and the Phase 3 content was then built and accepted on the corrected candidate. The staled work is not part of the accepted record, and it is not counted anywhere in this entry; the distinction is recorded here because a phase that documents the history of an experiment has to document the experiment’s own mis-steps with the same honesty it gives to the code.

The corrective action was a baseline fix, not a re-review of the diff: the continuity rule established in Phase 2 — each phase inherits the accepted candidate of the one before — is exactly the rule that protects against this class of defect, because no amount of review of a diff can catch content built on the wrong tree.

3.4 — Gate 3 and the checkpoint, as recorded

The Gate 3 disposition for Phase 3 is recorded as Pass with minor defects, and the approved Phase checkpoint outcome is recorded as confirmed as-is. The four minor, human-identified defects from that deployed-slice review — diagram presentation on the three embedded SVGs; status wording that did not yet document the previous complete phase per the one-phase-behind convention; Phase 2 journal timing wording that needed alignment with the recorded run data; and a leaked internal project reference on the Status / Roadmap page that needed replacing with the corresponding requirements text — were carried into the next phase’s scope as ordinary checkpoint elaboration. This entry does not claim them as corrected; they are the correction work the next phase is carrying, and its completed-change record — not this entry — is what will show them resolved. Keeping the three states separate (what the phase did, what the checkpoint found, what the correction pass is doing) is the record’s discipline.

3.5 — The numbers, and what they are and are not

The recorded source-fact statistics below are the verified Phase 3 and Phase 3.1 Controller records, read from the Controller records and included in full. The first run used the stale Phase 1-based source and did not receive an approved Phase Checkpoint; the corrective run is referred to here as Phase 3.1 — its Controller target phase is 3 on a new delivery. These runs are kept separate in the journal so the corrective run does not hide the earlier attempt, and every column carries its unit.

RunDispatch attemptsPassed outcomesRejected-review outcomesFailed dispatchesCancelledTimeoutsIterationsPhase result
Phase 3, stale-source attempt11225779104No approved Phase Checkpoint
Phase 3.1, corrected-source run4925122104Gate 3 Pass with minor defects; Phase Checkpoint approved as confirmed as-is
Combined161508101208 passed iteration recordsOnly Phase 3.1 reached an approved Phase Checkpoint

The unit separations this record keeps, stated rather than implied:

  • The pass, rejected-review, failed, and cancelled columns partition the dispatch attempts. A rejected-review outcome is a successful dispatch returned for correction, not a failed dispatch. The 4 iterations in each run are iteration records, not a completed phase: the 4 iterations in the stale-source run did not make that run a completed phase, and the two runs are not added into a phase count.
  • The dispatch attempts are attempts within run paths — they are not phases, and they are not iterations. No phase-success percentage is derived from these dispatch counts, and they are not combined with the synthetic acceptance runs. The broader development effort behind these phases involved more than 150 reported runs or attempts, including failed starts, Phase 1 runs, and non-automated runs; that is a different population and is not combined with the 161 dispatch attempts.
  • Two synthetic acceptance runs recorded around the phase (four passed / three failed; both ended unsuccessfully) are a separate population from project delivery. They are presented here only as recorded events, and they are not counted as Phase 3 deliveries or successes.
  • This site does not publish elapsed-time or duration averages for the phase: the recorded figures are counts, and a duration figure would be invented, so it is not printed.

3.6 — What Phase 3 actually established

On the record, the phase closed with: the accepted tree restored from the accepted Phase 2 candidate, so that the phase’s content sits on the continuity the record relies on; the five deliverables of 3.1 in that tree, each through the same Developer, Security, and Validator path everything here goes through; the Gate 3 disposition and checkpoint outcome recorded above, with the four carried defects named in 3.4; and the lesson, stated without softening it, that the baseline is a reliability problem of the same class as the handoffs Phase 2 spent its dispatches on — a phase started from the wrong tree inherits defects no review pass will find. A documentation phase built on that foundation needs the machinery, but the machinery’s rules — inherit the accepted candidate, bounded attempts, independent review, a checkpoint that names what stays open — are the part of the foundation that actually kept Phase 3 honest.

Related artefacts

  • The pull request that restored the accepted Phase 2 tree as the Phase 3 baseline after the stale-source attempt was found
  • The commit that authored the dated Phase 2 journal entry -- sections 2.1 through 2.7
  • The three Factory process diagrams added in Phase 3: Factory architecture and workflow, development iteration lifecycle, and project and phase lifecycle
  • The pull request that expanded Infrastructure / Lab with the component overview and the agent-execution and infrastructure-evolution sections
  • The site-wide status and cleanup pass: compact one-phase-behind status section, starter-template branding removal, and the stale-status audit