Status: Direction / planning (Jon-approved, 2026-06-04). The sequenced remaining work after the in-progress fumadocs-ui removal, plus the one records-lifecycle exception — contracts.

Remaining implementations

1. Records baseline lock — untangle the dirty working tree (Phase A remediation + Phase B document-nodes + docs are all uncommitted together). Commit the fumadocs-ui removal, then commit Phase A and Phase B as separate commits; run the Phase A re-gate and write a Phase B audit doc.
2. FeatureRegistryTable redesign — master–detail: a super-row per feature carrying the invariant info; one-line artifact rows showing each artifact's own status, a per-artifact verdict, a compact single timestamp, and the artifact's own uid; a full-width route. Built on the shadcn primitive layer.
3. Records v2 contract tightening — define the relationship-registry schema/edges; lifecycle semantics for the decision/runbook kinds (and the undefined implementation record); record_uid durability (24-hex vs multitenant); the Hindsight sync contract (endpoint / auth / bank / session / upsert).
4. Hindsight + Postgres — stand up via Docker/Postgres as a separate MCP endpoint; implement the sync; parallel-rollout against the current vector MCP before any cutover.
5. Tiptap / ProseMirror editor — editor + semantic diff + tracked-changes over the Phase B node projection; plus the PM→MDX reverse bridge (from-mdx.ts already does MDX→PM).
6. Monaco — code / diff surface.
7. Component foundation — shadcn primitives + Vercel AI Elements (assistant-ui secondary): the grounded primitive layer + agent-chat surface, feeding the agentic shell built next.
8. Agentic app shell (built in jwc-global now) — the 3-pane frame (side rail · center · right multifunctional workspace) as floating containerized rounded resizable panel cards (~25% tighter than OpenHands; full-width, resizable via react-resizable-panels/Allotment). Built here on the shadcn primitive layer as part of the foundation — the one canonical shell, never forked.
9. Clone + split from jwc (later, optional extraction) — if/when it happens, extract the jwc tenant from the already-built shell, leaving the generic convergence product. The clone inherits the shell; it does not build it.
10. Pillars converge — K (KAI registries), Chattr runtime + Letta, Blockdata parse/blocks/workflow-graph.

Optimal ordering

Immediate, sequential:

1. Records baseline lock — overdue; nothing should land on a 3-feature-deep dirty tree.
2. FeatureRegistryTable redesign — the first shadcn-primitive adoption, so it de-risks the component decision on a low-risk surface; it also fixes the status-misalignment bug and is the visible payoff of the records work. It is also the proving ground for the shadcn primitive layer the agentic shell (8) will be built on.

Then two parallel tracks (no shared files):

• Backend: (3) contract-tighten → (4) Hindsight + Postgres.
• Editor: (5) Tiptap/PM → (6) Monaco.
• Foundation (7) grows as the editor/shell need it, then the agentic shell (8) is built in jwc-global on that shadcn primitive layer — it is foundation work here, not deferred to a later product.

Pivot milestone: Tiptap (5) clean is the trigger for the optional clone/split decision — "after Phase B, especially if PM+Tiptap implements cleanly, I'll remove the jwc tenant." Do not front-run the split before Tiptap proves the all-format-editor thesis. Note: the clone/split is no longer the gate for the agentic shell — the shell (8) is built in jwc-global as foundation regardless of whether the split ever happens; the split, if taken, inherits the already-built shell.

Endgame: the agentic shell (8) is built in jwc-global as part of the foundation; then (9) clone/split (later, optional) → (10) pillars converge. The repo's "obstacles to clear first" gate step 9 (the optional split), not steps 1–8 — the shell is built here regardless.

The contract protocol (the lifecycle exception)

The records lifecycle — plan → audit → evidence → closure; current → under_audit → needs_revision → superseded → consumed → closed — governs mutable, time-series work-docs (dated YYMMDD-HHMMSS-<project>-<title>.mdx, where a newer doc supersedes the old).

Contracts are the one exception — documents that function as contracts / are fixed-immutable authorities (the design-token contract, the architecture contract, the records-system contract itself). They are authorities that other records depend on, so they get a separate protocol:

1. Distinct contract kind — singleton storage (<project>.mdx, not timestamped, not a stream), flagged immutable.
2. Lock authority = Jon only — agents draft/propose to an inbox; locked: true is human-minted, never by an agent.
3. Immutability = fail-closed on mutation — once locked, the content_hash is frozen; an in-place edit of a locked contract is rejected. The only legal change is a new version, with the prior version retained immutably.
4. Versioned + pinnable, not dated-supersession — consumers pin to a contract version; and via the Phase B node projection they pin at clause granularity (each clause = node_uid + content_hash, so an amendment updates only the changed clauses' hashes and existing references stay valid). The Phase B node layer is the immutability anchor.
5. Excluded from the work-doc lifecycle — deriveLifecycle / plan-states / assertActiveOpenPlan do not apply. The contract state machine is the short one: draft → proposed → locked → amended.
6. Binding + dependency-aware — the contract gate enforces conformance (contract-encode-first); the relationship registry tracks which records depend on which contract version, so an amendment flags affected dependents.

It is not a second system — it is the second protocol over the same Phase B document-node substrate. It folds into roadmap step 3 (records-contract tightening), sharing the relationship-registry-schema and lifecycle-semantics work already open there.

Why it matters: contracts are governance authorities that other records depend on; treating them as mutable, supersedable work-docs would make the governance unstable. Immutability + Jon-only lock + versioned amendment is what makes a locked contract trustworthy.