// The deal room (0079).
//
// ONE ROOM PER NEGOTIATION, THREE ROLES IN IT. The requester who owns the
// deal and the two Legal roles work the supplier's markup together: the
// changed paragraphs, a conversation anchored to them, and an analysis
// window beside them. The auditor holds no tab here — the record they read
// is the same tables, through the record. A paragraph can be opened on the
// CLAUSE WORKBENCH — the pair (as it stood / as they propose) with the
// advice on the record gathered around it.
//
// WHAT THE SCREEN DOES NOT DO, the negotiation surfaces' three rules:
//
// · It never checks a permission. Who may talk in which room is the
// schema's sentence; this offers the act and shows the refusal in the
// database's own words.
// · It never fetches broadly and filters for permission. Every read here
// takes no parameter; showing one room filters what the rule ALREADY
// returned.
// · Advice is labelled advice, everywhere it appears. The analysis window
// says on its face that it moved nothing and gates nothing, and an
// absent analysis renders its recorded reason, never a blank.
//
// LIVE-NESS: POLLING FOR THE ROOM'S RECORDS, THE EDITOR'S CHANNEL FOR THE
// DOCUMENT (S292/S293, Phase 4). The room refreshes every twenty seconds
// through the API endpoint list. For live co-editing, the self-hosted
// OnlyOffice Document Server manages document synchronization over its own
// appliance channel while custody stays in our append-only save record.
const { useState, useEffect, useRef } = React;
// How recent a recorded visit is before the screen stops calling the person
// "here". Presentation, not a control: the record keeps every visit.
const HERE_MINUTES = 10;
const POLL_MS = 20000;
// ── Reading the room ──────────────────────────────────────────────────────
// Fetched once here and handed down, the useNegotiationRecord shape. Nine
// calls rather than one wide one: each is its own rule.
function useDealRoomRecord() {
const negotiations = usePane(() => API.negotiations());
const rounds = usePane(() => API.negotiationRounds());
const deals = usePane(() => API.deals());
const analysis = usePane(() => API.roundAnalysis());
const comments = usePane(() => API.dealRoomComments());
const analyses = usePane(() => API.dealRoomAnalyses());
const visits = usePane(() => API.dealRoomVisits());
const people = usePane(() => API.people());
// The authored playbook beside the room (0081), the same read the
// negotiate desk makes — and DELIBERATELY kept out of the loading and
// failure aggregation below: these moves are advice, they gate nothing,
// and a refusal to show advice must not take the room down with it.
const positionMoves = usePane(() => API.positionMoves());
// The AI-6 register — what a model proposed sending back and what a named
// lawyer made of it. Advice like the playbook above: kept out of the
// aggregation, because a refusal to show advice must not take the room
// down with it.
const drafts = usePane(() => API.negotiationDrafts());
// The declared compliance concerns and the record of every check (0120).
// Advice for the same reason, and out of the aggregation for the same
// reason.
const concerns = usePane(() => API.complianceConcerns());
const complianceChecks = usePane(() => API.complianceAssessments());
// The editable working copy and its save history (0130). OUT OF THE
// AGGREGATION for the advice panes' reason turned around: this is not
// advice, but a room whose conversation is fine and whose working copy
// cannot be read is still a usable room, and taking the whole room down
// over it would lose the record people came for.
const workingDocuments = usePane(() => API.workingDocuments());
const workingSaves = usePane(() => API.workingDocumentSaves());
// The signature ceremony (0040, 0137). OUT OF THE AGGREGATION for the
// working copy's reason: a room whose conversation is fine and whose
// envelope strip cannot be read is still a usable room, and taking the
// whole room down over it would lose the record people came for.
const envelopes = usePane(() => API.envelopes());
const envelopeRecipients = usePane(() => API.envelopeRecipients());
const panes = [negotiations, rounds, deals, analysis, comments, analyses,
visits, people];
// 'loading' means the FIRST load only. A reload flips its pane back to
// 'loading', and the conversation reloads every POLL_MS — read naively,
// every poll would blank the pane to , unmounting the open Room;
// the Room re-enters on mount, reloads the visits, and the pane flashes in
// a visit-recording loop. Once everything has arrived, later reloads
// refresh in place on the rows each pane keeps while it refetches.
const everLoaded = useRef(false);
if (panes.every((p) => p.status !== 'loading')) everLoaded.current = true;
return {
negotiations, rounds, deals, analysis, comments, analyses, visits, people,
positionMoves, drafts, concerns, complianceChecks,
workingDocuments, workingSaves, envelopes, envelopeRecipients,
reloadWorkingDocument: () => [workingDocuments, workingSaves, rounds]
.forEach((p) => p.reload()),
reloadSignatures: () => [envelopes, envelopeRecipients]
.forEach((p) => p.reload()),
loading: !everLoaded.current,
failed: panes.find((p) => p.status === 'failed') || null,
reloadAll: () => panes.forEach((p) => p.reload()),
// The conversation moves faster than the record around it, so only the
// living surfaces are polled; the rounds and the deal list reload when
// an act reloads everything.
reloadConversation: () => [comments, analyses, visits]
.forEach((p) => p.reload()),
};
}
// ── Who is here ───────────────────────────────────────────────────────────
// Derived on every render from recorded visits: a name is "here" while its
// newest visit is younger than HERE_MINUTES. Nothing stores a live state.
function presenceOf(visits, negotiationId) {
const newest = new Map();
for (const v of visits) {
if (v.negotiation_id !== negotiationId) continue;
const at = new Date(v.entered_at).getTime();
if (!newest.has(v.person) || at > newest.get(v.person)) {
newest.set(v.person, at);
}
}
const cutoff = Date.now() - HERE_MINUTES * 60000;
const here = [], earlier = [];
for (const [person, at] of newest) {
(at >= cutoff ? here : earlier).push({ person, at });
}
here.sort((a, b) => b.at - a.at);
earlier.sort((a, b) => b.at - a.at);
return { here, earlier };
}
function WhoIsHere({ visits, negotiationId }) {
const { here, earlier } = presenceOf(visits, negotiationId);
return (
{here.length === 0
? nobody else has opened this room in the
last {HERE_MINUTES} minutes
: here.map((p) => (
{p.person}
))}
{earlier.length > 0 && (
earlier: {earlier.slice(0, 6).map((p) => p.person).join(', ')}
)}
);
}
// ── One comment, with its replies ─────────────────────────────────────────
// A margin bubble beside the document — the working shape Mike asked for
// (S286): who spoke, on which words, what they said, and exactly one way to
// respond. Display names, because colleagues talk to people, not addresses;
// the address stays in the tooltip, where the record can still be checked.
function Comment({ comment, replies, people, onError, onChanged, depth }) {
const [replying, setReplying] = useState(false);
const [busy, setBusy] = useState(false);
const name = (person) =>
(people.find((p) => p.person === person) || {}).display_name || person;
const act = async (call) => {
setBusy(true); onError(null);
const r = await call();
setBusy(false);
if (!r.ok) { onError(r.reason); return; }
setReplying(false);
onChanged();
};
return (
{depth === 0 && (
comment.state === 'resolved'
// chip-std, not chip-gone: struck-through is the superseded
// library's ink, and a resolved thread is settled, not gone.
? resolved act(() => API.reopenDealComment({
comment_id: comment.comment_id }))}>
reopen
: act(() => API.resolveDealComment({
comment_id: comment.comment_id }))}>
resolve
)}
{comment.to_person && (
for {name(comment.to_person)}
)}
{comment.quoted_text && (
// The words being talked about, set as a quotation — accent rule and
// italics, never a box that reads as somewhere to type.
);
}
// ── Saying something ──────────────────────────────────────────────────────
// `fixed` carries the anchor — the negotiation, optionally the round, the
// paragraph, the quoted words, the parent. The person typing chooses only
// their words and, optionally, a colleague to address. The compact shape
// stacks inside a margin bubble; the full shape is the room thread's one
// composer. Both post the same act.
function CommentForm({ people, fixed, quoted, compact, onError, onPosted,
onCancel }) {
const [note, setNote] = useState('');
const [toPerson, setToPerson] = useState('');
const [busy, setBusy] = useState(false);
const post = async () => {
setBusy(true); onError(null);
const r = await API.postDealComment({
...fixed,
quoted_text: quoted || fixed.quoted_text || null,
to_person: toPerson.trim() || null,
note: note.trim(),
});
setBusy(false);
if (!r.ok) { onError(r.reason); return; }
setNote(''); setToPerson('');
onPosted();
};
const quotation = quoted && (
);
}
// ── The analysis window ───────────────────────────────────────────────────
// AI advice on the record, labelled as advice on its face. The highlighted
// words arrive from a selection in a paragraph; the reply is the model's
// reading of them AGAINST THE RELATED RECORD — the open positions, the
// concessions, and the other changed paragraphs of the same document, which
// is where a cross-paragraph trade becomes visible. An absent analysis
// renders its recorded reason; the related-record report stands either way.
function AnalysisWindow({ negotiation, analyses, highlight, onClearHighlight,
onError, onAnalysed }) {
const [busy, setBusy] = useState(false);
const mine = analyses
.filter((a) => a.negotiation_id === negotiation.negotiation_id)
.sort((a, b) => b.analysis_id - a.analysis_id);
return (
Analysis (advisory)
Advice on the record, in a different pen. Nothing here moved a
position, wrote contract wording, or gated anything — and nothing
here can.
{highlight
? (
highlighted in paragraph {highlight.paragraph_index}, round {highlight.round_no}
“{highlight.quoted_text}”
{
setBusy(true); onError(null);
const r = await API.analyseHighlight({
...highlight,
});
setBusy(false);
if (!r.ok) { onError(r.reason); return; }
onClearHighlight();
onAnalysed();
}}>
{busy ? 'asking…' : '✓ analyse against the record'}
The model is shown the highlight, the paragraph, and the related
parts of this record — the open positions, the concessions, and
the other changed paragraphs — so a trade that spans paragraphs
is on the table. What it answers is recorded verbatim.
)
: (
Select words in a proposed paragraph to run the fixed analysis.
Nothing else in the record stood beside this paragraph.
)}
)}
);
}
// ── The working copy (0130) ───────────────────────────────────────────────
//
// THE ONE THING THE ROOM COULD NEVER DO. Every other surface here is a way to
// TALK about the supplier's paper; this is where the paper itself is changed.
// A copy opens from a round, each version is saved whole, and closing it is
// terminal — work continues by opening a new copy, never by reopening this
// one, because a closed copy's bytes may already be a fingerprinted round.
//
// WHAT IS NOT HERE YET, said plainly rather than left to be discovered: there
// is no editor in this panel. A person takes the round's file from the
// dossier, changes it in their own word processor and saves the result back
// here, and every version they save is kept with its author and its hash.
// The co-editing surface is the next phase; this is the record it will write
// to, with a way in that does not depend on it.
//
// IT DECIDES NOTHING, like everything else in this room. Every act below is
// offered to everybody and refused by the database in its own words — the
// room's rule 1, and the reason there is no role check anywhere in here.
function WorkingCopy({ negotiation, rounds, record, onError }) {
const { busy, run } = useActs();
const [seedRound, setSeedRound] = useState('');
const mine = record.workingDocuments.rows
.filter((w) => w.negotiation_id === negotiation.negotiation_id)
.sort((a, b) => b.working_document_id - a.working_document_id);
const live = mine.find((w) => !w.closed_at) || null;
const saves = live
? record.workingSaves.rows
.filter((s) => s.working_document_id === live.working_document_id)
.sort((a, b) => b.save_no - a.save_no)
: [];
const after = (r) => {
if (!r.ok) { onError(r.reason); return; }
record.reloadWorkingDocument();
};
const received = rounds.filter((r) => r.direction === 'received');
return (
Working copy
{/* THE PANE'S OWN FAILURE, SHOWN HERE AND NOT AS A BLANK. It is out of
the room's aggregation on purpose, so a refusal has to say so
somewhere or it says nothing at all. */}
{record.workingDocuments.status === 'failed' && (
The working copies could not be read: {record.workingDocuments.reason}
)}
{!live && (
No copy of this contract is open. Opening one takes the round's
file as its first version; every version saved after that is kept.
{received.length > 0 && (
)}
run('open', async () => after(
await API.openWorkingDocument(
negotiation.negotiation_id,
seedRound === '' ? null : Number(seedRound))))}>
open a working copy
)}
{live && (
Opened by {live.opened_by}
{live.opened_from_round != null
? ` from round ${live.opened_from_round}`
: ' from our own paper'}.
{/* THE HASH IS THE DATABASE'S ARITHMETIC over the stored bytes, and
it is shown for the same reason the dossier shows a round's:
it is what makes a version a thing you can point at later. */}
{live.latest_save_no == null
?
Nothing has been saved into it yet.
:
version {live.latest_save_no} · {live.latest_byte_count} bytes
{live.latest_saved_by} · {live.latest_sha256}
}
{
const file = e.target.files && e.target.files[0];
e.target.value = '';
if (file) run('save', async () => after(
await API.saveWorkingDocument(
live.working_document_id, file)));
}} />
Saved as the next version. Nothing is overwritten.
{/* Phase 4 (S292/S293): Issue the active working copy into the evidence chain as a new round */}
{(live.latest_save_no != null || saves.length > 0) && (
run('issue', async () => {
const r = await API.issueWorkingDocument({
negotiation_id: negotiation.negotiation_id
});
if (!r.ok) { onError(r.reason); return; }
record.reloadWorkingDocument();
record.reloadConversation();
})}>
issue as round {(rounds.reduce((m, r) => Math.max(m, r.round_no), 0) || 0) + 1}
)}
{/* TWO REASONS, AND THEY ARE DIFFERENT FACTS. `issued` means this
version went to the other side; `abandoned` means it did not.
A single "close" button would make the record unable to tell
them apart. */}
run('close', async () => after(
await API.closeWorkingDocument({
working_document_id: live.working_document_id,
closed_reason: 'issued' })))}>
close — sent to them
run('close', async () => after(
await API.closeWorkingDocument({
working_document_id: live.working_document_id,
closed_reason: 'abandoned' })))}>
close — abandoned
)}
{/* THE CLOSED ONES STAY VISIBLE. A negotiation works through several
copies, and "what did we send them in March" is answered here. */}
{mine.filter((w) => w.closed_at).length > 0 && (
);
}
// ── OnlyOffice Document Server Co-Editor (Phase 4, S292/S293) ─────────────
//
// THE LIVE CO-EDITING SURFACE. Connects to the self-hosted OnlyOffice Document
// Server appliance via JWT-signed DocsAPI configuration. Document custody stays
// in our append-only save table cw.working_document_save.
function OnlyOfficeEditor({ negotiation, onError }) {
const [config, setConfig] = useState(null);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
const editorRef = useRef(null);
useEffect(() => {
let unmounted = false;
API.onlyofficeConfig(negotiation.negotiation_id).then((res) => {
if (unmounted) return;
setLoading(false);
if (!res || res.error || res.status >= 400 || res.ok === false) {
const msg = res?.reason || res?.error || 'Could not load OnlyOffice editor configuration';
setError(msg);
if (onError) onError(msg);
return;
}
setConfig(res);
if (window.DocsAPI && window.DocsAPI.DocEditor) {
try {
editorRef.current = new window.DocsAPI.DocEditor('onlyoffice-editor-frame', res);
} catch (e) {
console.error('OnlyOffice initialization error:', e);
}
}
}).catch((err) => {
if (unmounted) return;
setLoading(false);
setError(String(err));
if (onError) onError(String(err));
});
return () => {
unmounted = true;
if (editorRef.current && typeof editorRef.current.destroyEditor === 'function') {
try {
editorRef.current.destroyEditor();
} catch (_) {}
}
};
}, [negotiation.negotiation_id]);
return (
OnlyOffice Live Co-Editor · Document custody: Clausewerk
{config?.document?.key ? `Key: ${config.document.key.slice(0, 10)}…` : 'Append-only version stack'}
{loading &&
Loading editor configuration…
}
{error && (
Editor not ready
{error}
)}
{!loading && !error && (
{!window.DocsAPI && (
Live Co-Editing Surface
OnlyOffice Document Server integration protocol is active. When the self-hosted OnlyOffice Document Server is running, the full live Word editor embeds here with real-time co-editing and tracked changes.
);
}
// ── The signature ceremony ────────────────────────────────────────────────
//
// THE ACTS THAT HAD NO SCREEN. The adapter seam, the endpoints and the
// unattended poll were all built and tested (0137, S441/S442), and until this
// panel there was no way for a person to start or stop a ceremony — the exact
// shape `a-built-thing-has-a-way-in.test.mjs` exists to name.
//
// WHAT IT DOES NOT DO, said here rather than discovered: it never reports the
// ceremony as finished. The envelope's state moves only when a provider event
// is recorded, through the definer trigger and no other way, so what this
// draws is always the record and never a guess about what the provider is
// doing. A completion arrives on the unattended tick, not from this screen.
function SignatureCeremony({ negotiation, record, onError }) {
const { busy, run } = useActs();
const [recipients, setRecipients] = useState([
{ name: '', email: '', party: 'theirs' },
]);
const [reason, setReason] = useState('');
const [voiding, setVoiding] = useState(null);
const mine = record.envelopes.rows
.filter((e) => e.agreement_id === negotiation.agreement_id)
.sort((a, b) => b.envelope_id - a.envelope_id);
const live = mine.find((e) => e.state === 'sent') || null;
const past = mine.filter((e) => e.state !== 'sent');
const recipientsOf = (envelopeId) => record.envelopeRecipients.rows
.filter((r) => r.envelope_id === envelopeId)
.sort((a, b) => a.ordinal - b.ordinal);
const after = (r) => {
if (!r.ok) { onError(r.reason); return false; }
record.reloadSignatures();
return true;
};
const named = recipients.map((r) => ({
name: r.name.trim(), email: r.email.trim(), party: r.party,
}));
const recipientsReady = named.length > 0
&& named.every((r) => r.name !== '' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(r.email));
// An unread envelope list is not an empty envelope list. In particular,
// do not offer a second send while the first read is still in flight.
if (record.envelopes.status === 'loading') {
return
;
}
if (record.envelopes.status === 'failed') {
return (
);
}
return (
Signature
{!live && (
Nothing is out for signature on this agreement. Sending takes the
contract as it stands, records the bytes it sent by their hash, and
names everybody it went to.
);
}
// ── Recent activity ───────────────────────────────────────────────────────
// Derived from the recorded acts, merged and aged — never a second log.
function Activity({ negotiationId, comments, analyses, visits }) {
const events = [
...comments.filter((c) => c.negotiation_id === negotiationId)
.map((c) => ({ at: c.commented_at, what: `${c.author} commented`
+ (c.paragraph_index != null ? ` on paragraph ${c.paragraph_index}` : '') })),
...analyses.filter((a) => a.negotiation_id === negotiationId)
.map((a) => ({ at: a.analysed_at,
what: `${a.analysed_by} analysed paragraph ${a.paragraph_index}` })),
...visits.filter((v) => v.negotiation_id === negotiationId)
.map((v) => ({ at: v.entered_at, what: `${v.person} opened the room` })),
].sort((a, b) => new Date(b.at) - new Date(a.at))
// Consecutive identical acts collapse to the newest one — the record
// keeps every visit, but a feed that repeats "opened the room" twelve
// times is noise, not derivation.
.filter((e, i, all) => i === 0 || e.what !== all[i - 1].what)
.slice(0, 12);
if (events.length === 0) return null;
return (
{events.map((e, i) => (
{e.what}{since(e.at)}
))}
);
}
// ── The document itself ───────────────────────────────────────────────────
// The round's received Word file, on the page: kept text as ink, the
// supplier's insertions in the accent, their deletions struck through —
// and the margin beside each paragraph carrying their comments (from
// inside the file) and ours (from the record). Working IN the document is
// the whole ask (S286): selection on the text raises comment / ask-the-AI
// on the exact words.
function DocumentSheet({ negotiation, round, comments, people, analysed,
onError, onChanged, onHighlight, onWorkbench,
absentFallback }) {
const doc = usePane(
() => API.dealRoomDocument(negotiation.negotiation_id, round),
[negotiation.negotiation_id, round]);
const [composing, setComposing] = useState(null); // {paragraph, quoted}|null
const [popover, setPopover] = useState(null); // {x, y, text, paragraph}
const sheetRef = useRef(null);
const body = doc.body || {};
const documentHere = body.document || null;
if (doc.status === 'loading' && !doc.body) {
return
{documentHere.filename || 'the received file'} · round {round} ·
{' '}as received, changes theirs
{/* The carbon-copy legend, stated where the reader can see it.
Deletions wear the superseded ink — struck and KEPT — never the
error red: a supplier's deletion is a proposal, not a fault. */}
);
}
// ── The clause workbench ──────────────────────────────────────────────────
// One paragraph, opened for judgement: the clause as it stood beside the
// supplier's markup of it, with the advice this product already keeps
// gathered around the pair — the model's plain reading (run through the
// analysis window, which stays in the margin), the register of proposed
// counter-language, and what this supplier's other contracts say close to
// this deal's paper. The room's three rules carry in unchanged: no
// permission is checked here, nothing gates, and advice is labelled advice.
//
// SINCE 0120 THE COMPLIANCE PANEL IS DRAWN — the register of concerns the
// company declared, the check act, and the record of every check with how
// much of the register each was read against. Until 0120 it was
// deliberately absent, because a panel with no measurement behind it would
// have been decoration claiming coverage never taken (the rack's rule).
function ClauseWorkbench({ negotiation, round, paragraphIndex, record,
onBack, onError, onHighlight }) {
// The round's file, for the markup runs. Its own read, its own rule; an
// absent file falls back to the analysed record of the same paragraph.
const doc = usePane(
() => API.dealRoomDocument(negotiation.negotiation_id, round),
[negotiation.negotiation_id, round]);
const [severity, setSeverity] = useState('Standard');
const [purpose, setPurpose] = useState('');
const [limits, setLimits] = useState('');
const [drafting, setDrafting] = useState(false);
const [said, setSaid] = useState(null);
// The newest analysis of this paragraph — a re-run appends (0052), and the
// bench shows what the newest run said, the Room's own rule.
const row = record.analysis.rows
.filter((r) => r.negotiation_id === negotiation.negotiation_id
&& r.round_no === round && r.paragraph_index === paragraphIndex)
.sort((a, b) => b.analysis_id - a.analysis_id)[0] || null;
const docPara = ((doc.body || {}).document || {}).paragraphs
? (doc.body.document.paragraphs || [])
.find((p) => p.index === paragraphIndex) || null
: null;
const analyses = record.analyses.rows
.filter((a) => a.negotiation_id === negotiation.negotiation_id
&& a.round_no === round && a.paragraph_index === paragraphIndex)
.sort((a, b) => b.analysis_id - a.analysis_id);
const proposals = (record.drafts.rows ?? [])
.filter((p) => String(p.negotiation_id) === String(negotiation.negotiation_id)
&& p.paragraph_index === paragraphIndex);
const proposedText = docPara
? docPara.runs.filter((r) => r.kind !== 'del').map((r) => r.text).join('')
: (row ? row.proposed_text : '');
const askForDraft = async () => {
onError(null);
setSaid(null);
const answer = await API.draftCounter({
analysis_id: row.analysis_id,
severity,
intended_purpose: purpose,
known_limitations: limits,
});
if (!answer.ok) { onError(answer.reason); return; }
setSaid(answer.body || {});
setDrafting(false);
setPurpose('');
setLimits('');
record.drafts.reload();
};
return (
{row.category_key && {row.category_key}}
{row.matched_position
? `touches position ${row.matched_position}`
: 'matched no position'}
)} />
{/* ── The pair ──────────────────────────────────────────────────── */}
as it stood
{row
?
{row.original_text}
:
This paragraph has no analysed record, so what it replaced is
not on hand here. Run the round analysis on the negotiate tab
and this side fills in.
}
as they propose · select words to act on them
{docPara
? docPara.runs.map((run, i) => run.kind === 'del'
? {run.text}
: run.kind === 'ins'
? {run.text}
: {run.text})
: row
? row.proposed_text
:
Neither the file nor an analysed record holds this
paragraph{doc.status === 'failed' ? ` — ${doc.reason}` : ''}.
}
{/* ── The model's reading, run through the fixed window ─────────── */}
The model's reading (advisory)
{proposedText
?
onHighlight({
negotiation_id: negotiation.negotiation_id,
round_no: round,
paragraph_index: paragraphIndex,
quoted_text: proposedText.length > 600
? proposedText.slice(0, 600) : proposedText,
})}>
analyse this whole paragraph
The fixed analysis opens beside this bench. Its saved result
is reused until the paragraph or governed context changes.