// The six workspaces.
//
// WP-U07 builds the SHELL: every workspace opens on what is waiting, the
// requester's deal list works with the pipeline rail as an open deal's header,
// and every remaining pane renders an honest empty state naming the package it
// lands in. The detailed panes arrive in WP-U08 through WP-U14.
//
// The rule for this file: a pane either reads a real endpoint or says it is not
// built. There is no third option, and in particular there are no example rows.
// The v4 concept mockup has a complete set of invented data and none of it is
// imported here.
const { useState } = React;
// ── The pipeline rail, per deal ──────────────────────────────────────────
// v3 drew this as one global state, so two deals at two stages shared a rail and
// the screen could only be telling the truth about one of them. Under decision
// U8 it is the header of an OPEN DEAL and takes its stage from that deal.
const STAGES = ['Intake', 'Manifest', 'Forge', 'Validate', 'Dossier'];
// The three statuses the record allows. `cw.agreement` carries
// check (status in ('negotiating','executed','terminated'))
// and this list is the screen's copy of it — kept here so the reachable-stage
// set below can be DERIVED rather than remembered.
const AGREEMENT_STATUSES = ['negotiating', 'executed', 'terminated'];
// Which stage a deal has reached, derived from its recorded status rather than
// held anywhere. A stored stage is a fact that starts drifting the moment
// anything else changes.
//
// THREE STATUSES, THREE ANSWERS, and the third is the one this got wrong until
// 2026-08-21. Until then anything that was not `executed` fell through to
// Manifest, so a TERMINATED deal — dead, closed, nobody will move it again —
// was drawn standing at an early stage of the pipeline, which reads as work
// somebody still owes. Three of the portfolio's forty-eight were sitting there.
//
// `null` is the honest third answer: a terminated deal is not at Manifest, and
// it is not past the end either. Past-the-end draws every stage done, which
// would say it completed a pipeline it never finished. It LEFT the rail.
function stageOf(deal) {
if (deal.status === 'executed') return STAGES.length; // past the end
if (deal.status === 'terminated') return null; // left the rail
if (deal.status === 'negotiating') return 3; // Validate
// AND NOTHING ELSE GETS A STAGE. This used to fall through to Manifest,
// which is how the terminated deals ended up standing there. A status this
// screen does not recognise is a status it cannot place, and placing it
// anyway — at the first stage, where it reads as "just started" — is the
// same untruth waiting for the next value somebody adds to the record.
return null; // not placeable
}
// A deal is LIVE only while it is still moving. Both other outcomes are closed
// — one successfully, one not — and neither belongs in a count of open work.
// Asked through stageOf so there is ONE rule about where a deal stands; a
// second `status !== 'executed'` anywhere else is how the six sites this
// replaced came to disagree with each other.
function isLive(deal) {
const at = stageOf(deal);
return at !== null && at < STAGES.length;
}
// Which rail positions the derivation can actually produce.
//
// DERIVED, NOT LISTED. stageOf is asked about every status the record allows,
// so a status added to the vocabulary — or a new branch in stageOf — changes
// this set on its own, rather than leaving a card printing a number nobody
// measured until somebody remembers to come back here.
//
// TODAY THE ANSWER IS ONE STAGE: {Validate}. That is not a bug in this line,
// it is what the derivation is worth. `cw.agreement.status` is three values
// wide, and Intake, Forge and Dossier are facts about runs, manifests and
// dossiers — other tables, which this screen does not read. So four of the
// five cards can never hold a deal, and until 2026-08-21 all four printed a
// confident `0`.
//
// `shell.jsx` already states the rule, for the navigation rack: "a rack
// showing 0 for an area it has not measured would be stating a fact it does
// not hold, so an unmeasured area shows nothing at all". Kept at the rack,
// broken at the strip.
const REACHABLE_STAGES = new Set(
AGREEMENT_STATUSES
.map((status) => stageOf({ status }))
.filter((at) => at !== null && at < STAGES.length)
);
function PipelineRail({ deal }) {
const at = stageOf(deal);
// A deal that is not on the rail is drawn struck rather than complete, and
// SAYS SO IN A WORD — colour alone would be the design set's first broken
// rule. Two ways to be off it, and they are not the same news: terminated is
// an outcome the record knows, an unrecognised status is this screen's own
// ignorance, and each says which it is.
const left = at === null;
const ended = deal.status === 'terminated';
return (
{STAGES.map((s, i) => (
{i > 0 && }
{s}
))}
{left && (ended
?
terminated
:
no stage for “{deal.status}”
)}
);
}
const pane = PANES[tab];
if (!pane) {
return (
);
}
// ── Notices, wherever you are (NT-4) ────────────────────────────────────
// Rendered HERE, once, above whatever pane the role opened — rather than
// added to each pane, which is how five copies of one panel start disagreeing
// about what "open" means. It draws nothing at all when nothing is open, so
// a quiet system stays quiet, and it never draws a zero.
//
// The scoping is cw.notice's own read policy: a role that HOLDS the read and
// has had nothing raised to it is answered an empty list rather than
// somebody else's business.
//
// IT NOW SAYS THAT OF EVERY ROLE, AND IT IS TRUE OF EVERY ROLE. It was false
// of one until 0098: a viewer was REFUSED here, 403, on every workspace they
// opened, because their grant did not include the notice view at all.
//
// Mike's decision of 2026-08-22 — everyone can send and receive messages —
// ended that, so a viewer is now answered the same empty list as anybody
// else with nothing waiting. It is worth two lines of history because the
// paragraph this replaces had ALREADY been wrong once, in the other
// direction, and was rewritten at length to be right. A comment about who is
// refused is the thing the next reader trusts instead of checking, and it
// goes stale the day somebody changes a grant.
//
// NoticesWaiting still names the 403 as its own case rather than folding it
// into "any failure draws nothing" — which was hiding a REAL failure for the
// roles that do receive notices, and which is why the branch stays even with
// nobody expected to reach it.
//
// The identity is passed to panes that need to know WHO is looking — the
// people console shows a countersign button only to a Legal admin, and no
// revoke button against the viewer's own row. Those are affordances, not
// permissions: the database refuses the acts regardless, and a pane that got
// this wrong would offer a button that fails rather than leak anything.
// THE SHEET ON THE DESK (design set, 2026-08-10). The workspace container
// is the dark desk; whatever pane the role opened is laid on it as one
// cream sheet. Wrapped HERE, once, so every pane — including the ones not
// yet redrawn to the design set — arrives on paper rather than on wood.
return (
{tab !== 'notices' && }
{pane(me)}
);
}