Before anything else, prove the server is answering: open http://127.0.0.1:8787/healthz.
Expect: the whole response body is {"ok": true}. If this fails, stop — nothing below this
line is meaningful.

In the fresh window open http://127.0.0.1:8787/kanban — deliberately NOT the home page.
Expect: the browser does not stay there. It replaces the URL with
http://127.0.0.1:8787/?tour=1 and renders the tour: masthead ◈ Observify with the subtitle
guided product tour, a chip DEMO · no live data in the header, and a right-hand panel
carrying the chip DEMO · seeded data.

Read the panel. Expect: counter Step 1 of 16, title The live session board, buttons
Skip, Back (disabled on step one), Next, and the key hint Esc closes · ← Back · → Next.
The stage below shows session cards labelled DEMO / — seeded, not your real fleet.

Click Next five times, watching both the counter and the stage. Expect: the counter walks
Step 2 of 16 through Step 6 of 16; the titles in order are The machine behind the work,
The Mac running the local work, Every open shell, The Plex server in detail,
Trust, then verify; the demo route chip on the stage changes with each
(DEMO /pi, DEMO /mac, DEMO /shells, DEMO /pi/plex, DEMO /holt); and the address bar
tracks the step (/?tour=1&step=6). Click a link inside the stage — Expect: nothing
navigates; the sealed demo swallows the click.

Hold the right-arrow key until the counter reads Step 16 of 16. Expect: the last step is
titled The kit report suite, and the Next button's label has changed to Finish. Click
Finish. Expect: you land on http://127.0.0.1:8787/ — the real dashboard, with no
DEMO chip anywhere.

Final check: reload /kanban. Expect: the tour does NOT auto-open a second time; the page
renders directly, and a Tour button sits in the masthead to reopen it on demand.

Read the masthead left to right. Expect: ◈ Observify as the heading, the page subtitle
live sessions under it, then the navigation, then a Tour button, then a crescent theme
button ☾, then four metrics: <N> active, $<X> known total, window 45m, updated <time>.
The <N> active count equals the number of session cards you can count in the body.

Read the primary navigation. Expect: exactly two direct links, ◈ Live and ◈ Holt, then
four dropdown buttons Observability ▾, Machines ▾, Boards ▾, Reference ▾, then a
dashed-border button ☰ All Routes ▾ at the end.

Open each dropdown in turn. Expect: Observability holds Sessions, Capture, Memory;
Machines holds Pi, Plex, Mac, Shells; Boards holds Kanban, Bounty, Test Plans,
Game Build; Reference holds Docs, Kit Report, Browse Reports followed by one link per
live HTML report in reports/ (observed 2026-08-07: Apps, Company, Entabeni Kit,
God Kit, Kit Atlas, Kit Drift, Models, Orchestration Kit, Org Chart, Scars,
Terminus Findings, Terminus Kit). Opening one dropdown closes the previous one.

Open ☰ All Routes. Expect: a wide two-column panel with a heading per domain — Live,
Holt, Observability, Machines, Boards, Reference — repeating every link above, plus a
final group headed Other. Press Esc. Expect: the panel closes and keyboard focus
returns to the ☰ All Routes button.

Look at the bottom-right corner. Expect: a pill badge reading updated just now, a ·
separator, next 3m 00s, and a circular ⟳ button. Watch it for thirty seconds. Expect:
the right half counts DOWN once per second (next 2m 30s) while the left half stays pinned at
updated just now — this page re-polls /api/sessions every four seconds, so its data really
never is more than a few seconds old. Now open /docs and watch the same badge there.
Expect: on that page the left half DOES count up (updated 12s ago), because a static page
has no poll of its own. The countdown and the freshness readout are independent by design.

Final check: navigate to /docs, /testit, and /kanban. Expect: the same masthead,
the same navigation set, and the same refresh badge on all three — only the subtitle under
◈ Observify changes (reference, User Tests, fleet project boards).

Read the page. Expect: browser tab title Project index — Observify; masthead subtitle
fleet project boards; kicker APP DIRECTORY; heading One board per app; the blurb
Every non-hidden top-level directory in ~/Projects has its own fixed-column board. This page is
navigation only; cards from different apps are never mixed here.; and a green pill reading
<N> projects (observed 2026-08-07: 29 projects).

Count the tiles below. Expect: the tile count equals the number in the <N> projects pill,
exactly. Every tile heading is uppercase and prefixed, e.g. OPERATION OBSERVIFY,
OPERATION MILKSHAKE, OPERATION KIT.

Read the OPERATION OBSERVIFY tile. Expect: a <N> cards figure at its right, a row of
per-column chips naming only the columns that are non-zero (observed 2026-08-07:
in progress 14, running 1, in development 1, done 4, deployed 1), and a signal line
that names either a live session, a git timestamp, or the honest
no live session or git signal. A tile never shows a chip for a column it has zero cards in.

Type observ into Search operations…. Expect: the tile list narrows to the matching
board(s) and a count appears beside the box in the form <shown> / <total> (observed
2026-08-07: 1 / 29). Now type zzzzzz. Expect: every tile disappears and the message
No boards match that search. is shown — not a blank area. Clear the box. Expect: all
tiles return and the count indicator goes blank.

Final check: open http://127.0.0.1:8787/kanban/projects directly. Expect: the identical
page — same title, same pill, same tiles. It is an alias, and the ☰ All Routes panel lists it
under Other as Kanban (app directory) for exactly that reason.

Read the board header. Expect: URL http://127.0.0.1:8787/kanban/project/observify; tab
title OPERATION OBSERVIFY — Observify; kicker PROJECT BOARD; heading OPERATION OBSERVIFY;
a pill <N> cards; a back link ← app directory; and the sourcing paragraph beginning
Cards are harvested from this app's BACKLOG/NOTES/TODO/ROADMAP files, handoff tokens,.

Read the column headers left to right. Expect: exactly seven, in this order, each with a
count badge: Backlog, In Progress, Currently Running, In Development, Testing,
Done, Deployed. The set is fixed — no board may add, drop, or reorder a column.

Look immediately above the columns. Expect: a small line reading
background refresh last succeeded <age> · stale after 270s, where <age> is a real relative
time such as 29s ago. If instead a red STALE KANBAN CACHE banner is showing, record it here
and continue — the banner appearing is correct behaviour when the cache really is old; the
defect would be a stale cache with no banner.

Click any card in In Progress sourced from NOTES.md — for example the one titled
Kanban card-detail modal + overflow fixes — shipped 2026-07-28. Expect: a modal opens
showing the card's title, its full text, the label Associated files, and a list. The first
entry reads card source · found with the path /Users/wolf/Projects/observify/NOTES.md, a
size, a touched <UTC timestamp> line, and a copy path button. Click copy path. Expect:
the button briefly reads copied.

Press Esc. Expect: the modal closes. Now click a card in Currently Running (if the
column is empty, do F5 first and return here). Expect: the modal opens and says
No files associated with this card — nothing on-disk it references or was authored from. —
a live session has no source file, and the app must say so rather than invent one.

Final check: the Testing column shows the count 0 and the body text
No cards in this column. Check three other boards from the directory. Expect: every one of
them also has an empty Testing column — as of 2026-08-07 no board in the fleet has ever placed a
card there, which is a fact about the fleet, not a rendering failure.

Read the Currently Running column as it stands. Expect: either the honest empty state
No cards in this column., or one card per live session/dispatch whose working directory is
this project. Record what you see.

Open a Claude Code (or agent-dispatch) session with its working directory set to
~/Projects/observify, then click the ⟳ button on the refresh badge twice, about 30 seconds
apart. Expect: within roughly 30–60 seconds a card appears in Currently Running whose text
has the shape **<runtime or model>** (<8-character id>) — "<recent activity>" · <detail>,
where <detail> is either following: **<card name>** or the honest
no matching card found in current activity.

Read that card's decoration. Expect: a green dot and the word live at the top of the card
(● live, optionally followed by · <model>), a green left border, the project path
/Users/wolf/Projects/observify in the footer, and a recency stamp of the form
<n>s ago · <Month D, YYYY · h:mm:ss AM/PM EDT> — seconds old, not minutes.

End that session, then refresh twice more, about 30 seconds apart. Expect: the card
disappears from Currently Running. It must not linger as a ghost and must not migrate into
another column.

Final check: with the session gone, reload /kanban. Expect: the OPERATION OBSERVIFY
tile's running chip is gone (a chip is only rendered for a non-zero column) and its
<N> cards figure has dropped by one.

Click the ⟳ button. Expect: the badge outline turns accent-coloured and the ⟳ glyph
spins while the fetch runs, then the badge settles back to updated just now and the countdown
resets to next 3m 00s. The board content is replaced in place — no white flash, no full page
reload.

Check your place after that refresh. Expect: the page is still scrolled exactly where you
left it, and the board's horizontal scroll position is preserved. Nothing jumps to the top.

Leave the tab untouched and watch the countdown run to next 0m 00s. Expect: at zero the
badge refreshes by itself — the same in-place board swap as step 1 — and the countdown restarts
at next 3m 00s. Budget three minutes for this step; do not click anything while waiting.

Go to /testit (a page with no live poll of its own), scroll down, and click ⟳. Expect:
only the page body is swapped — no white flash, no browser reload spinner — and your scroll
position is unchanged. Now do the same on /docs. Expect: a genuine full page reload there
(the tab spinner turns), and your scroll position is restored afterwards. The difference is
deliberate: /docs carries inline scripts that a body swap would silently kill, so it opts into
a real reload.

Final check: back on /kanban/project/observify, compare the <N> cards pill in the hero with
the total of the seven column badges after a manual ⟳. Expect: they agree. ⚠ KNOWN DEFECT —
they can disagree: the in-place refresh replaces only the board element, so the hero pill and the
Central BACKLOG.md sample: timestamp keep their original server-rendered values until you do a
real page reload. The correct behaviour is for the pill to track the board it sits above.

Run this and compare with the green pill on /kanban:
curl -s http://127.0.0.1:8787/api/kanban | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['project_count'],'projects /',d['app_count'],'cards')"
Expect: the printed project count equals the <N> projects pill on screen, and equals the
number of tiles rendered.

Run:
curl -s "http://127.0.0.1:8787/api/kanban?project=observify" | python3 -c "import json,sys; d=json.load(sys.stdin); [print(c['title'],len(c['cards'])) for c in d['columns']]"
and put it beside the open OPERATION OBSERVIFY board. Expect: seven lines, in the same
order as the columns on screen, each number matching that column's badge exactly.

From the same payload read selected_project.card_count:
curl -s "http://127.0.0.1:8787/api/kanban?project=observify" | python3 -c "import json,sys; print(json.load(sys.stdin)['selected_project']['card_count'])"
Expect: it equals the hero pill's <N> cards after a full page reload, and equals the sum
of the seven column badges.

Run curl -s http://127.0.0.1:8787/api/testit | python3 -m json.tool and compare with the
cards on /testit. Expect: one JSON entry per card on screen, and each entry's
progress.checked / progress.total matches the <checked>/<total> figure printed on its
card.

Final check: reload /kanban and immediately re-run the step 1 command. Expect: the two
agree again. If they differ by exactly the number of live-session cards that started or stopped
between the two reads, that is honest movement, not a failure — say so in the notes rather than
marking a fail.

Read the page header. Expect: kicker INTERACTIVE CHECKLISTS, heading User Tests, the
line Manual plans discovered one level under ~/Projects., and on the right a count reading
<N> plans above state persists per project.

Read the cards. Expect: one card per project under ~/Projects that has a
USER_TESTING.md — including a card headed observify. Its kicker is USER TESTS, its counter
reads 0/70 on a first-ever visit, its footer reads 0 pass, 0 fail, 70 items, and its
body shows this file's Derived from: line, beginning
Derived from: commit 53f4d7d (dev) plus uncommitted working-tree edits.

Click the observify card. Expect: you land on http://127.0.0.1:8787/testit/observify;
tab title observify User Tests — Observify; kicker USER TEST PLAN; heading observify; a
counter 0/70 checked · 0 pass · 0 fail; and a section heading Flows beside the hint
check each step and final check.

Scroll the flow list. Expect: twelve flow blocks with kickers F1 through F12 in order,
each showing this document's flow title, its italic purpose line, its
Persona / precondition: line, a per-flow counter 0/<n>, and one row per numbered step plus
one row for that flow's Final check. Every row has a PASS and a FAIL button and a
notes (optional) input.

Click PASS on the very first row of F1. Expect: the row turns green, a checkmark draws
itself, the row's text gets a strike-through, the F1 counter becomes 1/6, and the hero
counter becomes 1/70 checked · 1 pass · 0 fail. Now click FAIL on the second row.
Expect: that row turns red and shakes once, and the hero reads
2/70 checked · 1 pass · 1 fail.

Type probe into the second row's notes box and press Enter. Then reload the page with
F5 / Cmd-R. Expect: after the reload the first row is still green, the second is still red,
the note still reads probe, and the hero counter still reads
2/70 checked · 1 pass · 1 fail. Click the green row's PASS button again. Expect: it
toggles back to unchecked and the hero drops to 1/70 checked · 0 pass · 1 fail.

Final check: in a terminal run cat ~/.observify/testit/observify.json. Expect: a JSON
object with an items map holding one entry per row you touched, keyed F1.1, F1.2, … each with
a status and a ts. Then click reset all at the bottom of the page and cancel the browser
confirm Reset every User Test item? — Expect: cancelling changes nothing, and your ticks
survive.

Look at the far right of the masthead. Expect: the page renders LIGHT by default, and the
theme button shows a crescent ☾.

Click ☾. Expect: the whole page switches to the dark palette immediately — background,
cards, and text all change together, with no light-coloured island left behind — and the button
glyph becomes a sun ☀.

Without touching the button again, navigate to /kanban, /testit, /docs, /mac, and
/bounty. Expect: every one of them renders dark and shows ☀. The choice is stored under
the obs-theme key and shared by the whole app.

Open /game. Expect: the game build page has NO theme button — it ships a single fixed
look by design. Navigate away to /docs. Expect: you are still dark; visiting /game did
not clear the preference.

Final check: in a fresh private window (no stored preference) open /memory. Expect: it
boots DARK while every other page boots light — this is the one ratified exception, not a bug.
Click its ☾/☀ button. Expect: it switches and the choice then applies everywhere else too.

Click ◈ Live, then ◈ Holt. Expect: / renders with tab title Observify — Live
Sessions and subtitle live sessions; /holt renders with subtitle Holt dashboard and a tab
title beginning Holt · Education, Terminus, Corpus, Kit atlas, Commands, Questions.

Walk Observability. Expect: Sessions → Agent sessions — Observify / subtitle
agent sessions store; Capture → Capture log — Observify / capture data — observer log;
Memory → Memory Pipeline — Observify / a subtitle of the form
memory pipeline · <n> live trees · <m> cycles with real numbers, not placeholders.

Walk Machines. Expect: Pi → wolfplex · Pi detail — Observify / Pi detail; Plex →
wolfplex · Plex detail — Observify / Plex detail; Mac → This Mac — Observify /
This Mac; Shells → Every Shell — Observify / every shell. None of them shows a Python
traceback or an empty body.

Walk Boards. Expect: Kanban → Project index — Observify; Bounty →
Bounty — Observify; Test Plans → User Tests — Observify; Game Build →
I Drink Your Milkshake · Game Build — Observify.

Walk Reference. Expect: Docs → Docs — Observify / subtitle reference; Kit Report →
the report cover titled think-like-fable — Kit Report; Browse Reports →
Kit health — Observify / kit reports. Then open three of the individual report links.
Expect: each renders a real report page, never a 404 and never a raw file download.

Final check: open /testit/observify — a drill-down, not a top-level destination. Expect:
the Boards ▾ dropdown button is highlighted in the accent colour, and opening it shows
Test Plans marked as the current page. A child page must light up its parent, not nothing.

In the browser open http://127.0.0.1:8787/kanban/project/nope. Expect: HTTP 404 and the
plain-text body unknown project — no styled page pretending the board exists, no empty board.

Open http://127.0.0.1:8787/testit/nope and then http://127.0.0.1:8787/nosuchpage.
Expect: both return HTTP 404 with the plain-text body not found.

Run curl -s -i "http://127.0.0.1:8787/api/kanban?project=nope" | head -1 and then the same
URL without -i. Expect: status 404 and body {"error": "unknown project"} exactly.

Run curl -s "http://127.0.0.1:8787/api/kanban/card?project=observify" (deliberately omitting
key). Expect: {"error": "project and key are required"} with status 400 — a missing
parameter is a client error, not a 500 and not an empty result.

Run curl -s "http://127.0.0.1:8787/api/testit/nope" and then
curl -s "http://127.0.0.1:8787/api/testit/agentify%2F..%2Fetc". Expect: BOTH return
{"error": "unknown user test plan"}. The traversal attempt must be refused by the same code
path as an ordinary typo — no directory listing, no file content, no different error that
confirms the path shape.

Back on the OPERATION OBSERVIFY board, open the card titled
Full performance spec (P1-P11) built, audited, deployed, committed — complete 2026-07-28
~21:20. Expect: its Associated files list mixes found and missing entries, and every
missing one says not found on disk under a real absolute path with an
as written: <original text> line above it. A reference the app cannot resolve must be
reported as missing, never silently dropped and never invented.

Final check: after all of the above, re-run curl -s http://127.0.0.1:8787/healthz.
Expect: {"ok": true} — none of the bad input above took the server down or wedged a worker.

Open http://127.0.0.1:8787/kanban/project/observify and click the card whose text starts
observify (~/Projects/observify) — 2026-07-28: Kanban overhaul. Expect: the modal loads
this card's text and its associated files. ⚠ CURRENTLY FAILS: the modal shows
Could not load this card — the board may have refreshed. Close and try again. and never
recovers, however many times you retry. Root cause: the page derives each card's
data-card-key from the REDACTED card text (kanban_page runs _public_render_model before
_kanban_board_html), while /api/kanban/card recomputes the key from the UNREDACTED
snapshot — so every card containing a redacted secret is permanently unopenable. Measured
2026-08-07 by opening every card on every board: 18 broken rows (17 distinct cards) out of 278
rendered, spread across 14 of the 29 boards.

Open http://127.0.0.1:8787/kanban/project/milkshake. Expect: each distinct backlog item
appears once. ⚠ CURRENTLY FAILS: the board reports 44 cards, but only 22 are distinct — ten
Backlog cards and one Done card each appear THREE times. The same ROADMAP text is harvested
once per copy of the file (_worktrees/first-pour-m1-native/ROADMAP.md, game/ROADMAP.md,
play/ROADMAP.md) with no de-duplication on identical card text. A second, milder instance:
OPERATION HOLT-ECOSYSTEM-PACKETS shows 22 cards for 21 distinct ones.

Open http://127.0.0.1:8787/bounty. Expect: the pill count equals the number of distinct
engagements. ⚠ CURRENTLY FAILS: the pill says 4 programs and four cards render, but there are
only two engagements — KAYAK appears twice (once labelled Holt, once holt-spine) and
Dispatch packet appears twice the same way. Both KAYAK cards link to the identical URL
/bounty/kayak, so the duplicate is a discovery artefact of two workspaces holding the same
company/programs files, not two real programs.

Open http://127.0.0.1:8787/bounty/kayak and find the Compliance Officer department card.
Expect: either a parsed report, or an honest empty state that does not expose the source
file's internal authoring comment. ⚠ CURRENTLY FAILS: the card renders the headline
unparseable, the filename compliance-sweep-2026-07-27.md, the message
couldn't parse this report without inventing data, and a link here's the raw file →.
Follow that link. Expect: the report. Instead the document opens on the file's leading
<!-- … --> block verbatim — an internal dispatch note about model routing and staffing
defaults, shown to the reader before any report content. Note also that observify's own ticket
for this (NOTES.md, visible as a card on the OPERATION OBSERVIFY board) describes the older
symptom — the comment inline in the card preview, from the earlier file
compliance-hr-sweep-2026-07-26.md — so the ticket text is now stale even though the underlying
defect is not.

On the OPERATION OBSERVIFY board, open the card
Full performance spec (P1-P11) built, audited, deployed, committed. Expect: the
Associated files list contains files. ⚠ CURRENTLY FAILS: it also lists the URL paths
/api/sessions, /pi, /kanban and /shells as missing FILES, and lists / as
found · directory — the machine's filesystem root, resolved from a backtick span that was
always a route, never a path. Root cause: _kanban_looks_like_file_ref accepts any backtick
span containing a /.

Open the ☰ All Routes panel and read its Other group. Expect: only real pages. ⚠
CURRENTLY FAILS: alongside the two legitimate entries (Kanban (app directory),
Mac Atlas (full view)) it offers App.css, App.js, Memory.css and Memory.js. Click
App.css. Expect: a page. Instead the browser leaves Observify and dumps raw stylesheet
text from /static/app.css. The router-derived destination list already filters /static/
out; the list that actually backs this panel does not.

Final check: count how many of the six steps above you marked fail. Expect: six, on
2026-08-07. Any step you can mark pass means that defect has been fixed since this plan was
derived — record which, and re-derive this flow.