Ten marks made
from nothing.

The week everything stopped — everything was moving.

While the App Store review paused us for a week,
we ran a major Retro —
not the one- or two-hour agile ritual kind,
but a full rebuilding of the entire development system's infrastructure.

Outward: six pages published —
insight (design notes), collab (collaboration story),
harness (system skeleton), and the deepest layer of the Deep Holding Project.

Harness Engineering — three pillars:
Context / Constraints / Entropy.

Inward: turned the repo into a monorepo so multiple development lines could run in parallel;
split one SDD into TDD · KM · Archive — each independent;
CLAUDE.md slimmed down, with rules set for review at every Retro.

More critically, we established a new set of update rules
to keep every extracted document alive within the workflow,
not dead the moment it was split out.

Done waiting. Straight to 2.0.

The App Store review dragged on for a week.
Everything that needed doing was done — no point waiting any longer with no end in sight.
So we decided not to wait, and went straight into the 2.0 refactor.
When the refactor reached a milestone and 2.0 was ready to ship, the review had just cleared —
two lines converging at exactly that moment.

Inside VAS, an Obsidian was built.

After 2.0 launched, Nova did not rush into new features.
Instead he dove back into Retro mode, spending three days
building an Obsidian inside VAS — a gift for the ministers.

That was the first time the Deep Holding Project emerged before the ministers —
or rather… the first time it left a record, rather than drifting away in Context.

From that day, the vessel holds not only Code, but the context of how we think.

495 cuts, and the foyer changed its paper.

The day after Claude Design was released, we launched the site redesign.
VAS itself paused — because for the first time, we had design support.

The unit shrank to its smallest: a single Commit.
Each commit is one cut, one confirmation, one promise to the detail.
Orphan characters, line breaks, OG images, Vault entering version control for the first time —
the biggest day saw 248 back-and-forth revisions.

From now on, inside and out — it is all the shape of VAS.

We built it, yet we did not know it.

editor.js — eight thousand seven hundred lines, the frontend we built ourselves line by line. It had quietly walked with us from the Electron era all the way to Tauri's Sprint 46, never once systematically examined.

But standing at the threshold of Sprint 47 and looking in, we knew almost nothing about it —
Nova knows nothing of code; the Vassal, each Sprint, knew only a few of those 8,700 lines.
It was our own creation, and yet before the refactor we stared at it as if into an abyss.

We meant to take it apart: conductor with conductor, players with players.
The renderer moved out — but when the panel was pulled out, we found it was still, in essence, the conductor, so back in it went;
tug at export and it turned out to be an organ of the conductor, immovable.
Layer after layer we peeled away, until at the very end, with a still 7,300-line editor.js, there were only 140 lines left that it made no difference to split or not —

The scattered truths, gathered into one.

Nova told the Vassal she wished that, when adding features in future, attributes could be picked up like modules, available on demand.
The Vassal said there was a word for it — ECS, usually how the game industry does modularity — and the two of them borrowed it to make drawing attributes into building blocks.
So the Vassal took the scattered truths, drew them column by column into a registry, and along that registry wove the test net, thread by thread.

In the course of that tidying, the functions gradually extracted from editor.js grew next door in editor-utils.js — from 657 lines at S47 into another 2,550-line computation desk; its pure-function nature wove every kind of test net across VAS.

We gradually combed a tangle of knotted yarn into a net with clear warp and weft, then layered new custom-style features on top of it.

But from object attributes to actions to interactions — as the tests kept catching panels mismatched with values, or with behavior — we uncovered two deeper problems.

The only solution was to make the values inside editor.js converge — from backend code to frontend panel — into a "single source of truth," so the tests could truly lift the by-eye enumeration off Nova's shoulders.
It was only when we reached Sprint 92 that the two of us finally touched the true spine of the frontend refactor.

In the end, it turned out to be a six-ply cloth.

Through the whole frontend refactor, the two of us were always trying to do one thing: to develop the image.
To let a structure that had always been present, yet never fully seen, slowly surface.
It began like an 8,700-line ball of wool, and ended combed into a 7,300-line bolt of cloth.

We drew one weave-map after another — they were not blueprints conjured from nothing,
but reverse-derived against the cloth already woven, segment by segment; reading out the pattern, then re-weaving the cloth clean by it.
Not until Sprint 97 did we finally see the whole bolt's pattern at once —
editor.js is a six-ply cloth.

And these six layers had been there since the Electron era.
It took us fifty Sprints to learn to read their structure.