Contract Register — Controller Guide

The Contract Register is the flat, auditable list of every contract document you hold — each base award, every modification, every option exercise — laid out one row at a time with a running total of ceiling and funding. Almost everything downstream (invoicing, revenue recognition, funding alerts, closeout) reads the contract's facts from here, so this is the record that has to be right. This guide explains what the register holds, walks the exact clicks to read it, and shows the one sanctioned way to correct a billing rate. It assumes you run a business but aren't necessarily a career government accountant.

note

Where it lives

Left nav → Contracts → Contract Register (/accounting/contracts/register). Two neighbors do the editing the register only shows: the per-contract detail page (Contracts → Contracts, then click a contract → /accounting/contracts/:id) and the Contract Documents review queue (/accounting/contracts/proposals), which you reach from the Contracts list via the Upload & review proposals link.

---

The limitation-of-funds notice

When a contract carrying FAR 52.232-22 crosses a funding threshold, its alert on the contract detail page is tagged FAR 52.232-22 letter required. That clause obliges the contractor to notify the contracting officer in writing before the allotted funds are exhausted. Acknowledging the alert dismisses it. It does not discharge the obligation. The notice panel under the alert is where that gets done.

The two figures the clause asks for

FAR 52.232-22(b) requires the notice to state the estimated additional funds required to continue performance for the period stated in the schedule, and the date the allotted funds are expected to be exhausted. Both are computed here from this contract's own numbers: the costs the funding engine measured, the funds currently allotted, and the base period on the contract. The daily rate is this contract's own average over its elapsed period. Nothing is estimated by a model and nothing is carried in from another contract.

Costs incurred and Currently allotted are shown beside them so the arithmetic is legible: the letter states all four.

Drafting and sending

Draft the notice writes the letter around those figures, addressed to the contracting officer on the contract, citing the clause. It may use only the facts in the panel. A draft that names any other dollar figure or date, that fails to name the contract number, or that threatens to stop work, demands payment or asserts entitlement to costs above the allotted amount is discarded before you see it, and the standard wording is kept instead. Where no model is configured for your tenant, the standard wording is what you get, and it is a complete notice.

Read the letter, then Copy it and send it the way correspondence on this contract goes out. I sent this records that it went, against the alert. Arcvue does not mail a contracting officer.

When no letter can be drafted

The panel says why, and each reason names your next action. The most common is that no document on the contract determines whether FAR 52.232-22 applies -- the clause flag is genuinely unknown, not known to be absent, and the system will not assert an obligation it cannot establish. Upload the award or modification that carries the clause, or record the determination, and the letter can be drafted. The others are a missing base period, a missing funded value, or no cost attributed to the contract yet.

Part 1 — The ideas you need first (read once)

Why the register is the source of truth

Invoicing, revenue recognition, the JSR, funding alerts, and closeout all read the contract's facts from here: its type (T&M / FFP / CPFF / CPAF / CPIF / IDIQ / hybrid), its period of performance, its funding (base + exercised options + modifications), and its billing rates / labor categories (LCATs). If a number is wrong here, it's wrong everywhere downstream — so the register is the highest-leverage record to keep clean.

One row per document, in audit order

The register is deliberately not one row per contract. It's one row per document: the base award, then each modification, then each option exercise, sorted contract number ascending, base-award-first, then modification number. Each row shows what that document changed — its Ceiling Δ and Funded Δ — next to the Running Ceiling and Running Funded those deltas roll up to. Reading down a contract's rows is how you confirm the cumulative funding math is right and spot a missing mod before it propagates.

The base-award row is derived: it shows the contract's current ceiling and funding less every modification recorded beneath it, so the running columns always end at the figures the contract's own page shows. A base award that reads oddly small, or negative, means a modification is recorded that the contract's current figures do not include — that is the row to look at.

How contract data gets in

Contract terms are extracted from the executed documents (the award and its modifications) and reviewed by a human before they land — not hand-typed from memory. You upload the PDF, an AI extractor reads it, and you approve (or correct) the extraction in the Contract Documents queue. Each modification updates the running totals: funding increments, option exercises (which extend the period and add funding), price and scope changes.

Billing rates come from the document — one path only

The billing rates and labor categories that feed invoicing come exclusively from the executed contract document, through the document/correction path — never typed straight into the register or the LCAT table. This single-writer rule exists because rates feed invoices: a rate entered two different ways is a rate that eventually disagrees with itself. So the register rows are read-only, and the LCAT rate table on the contract detail page is explicitly "not editable here." To fix a rate you flag it and correct the underlying document, which routes through the one sanctioned writer.

What Arcvue deliberately will not do

• It won't let you hand-edit a billing rate inline. Corrections go through the document path so there's a single source of truth for what feeds invoices.
• It won't guess a contract's funding — the running totals reflect the extracted base plus the recorded modifications and option exercises, nothing more.
• It won't let you edit a contract from inside the register at all. The register is a read-only ledger; editing happens on the detail page and in the document queue.

---

Part 2 — How to run it

Step 1 — Open the register and read the running totals

In the left nav, go to Contracts → Contract Register (/accounting/contracts/register). The page header reads Contract Register — "Flat audit table — every contract document in order."

You get a table with one row per document. The columns, left to right, are: Contract #, Customer, Entity, Type, Document, Mod #, Eff Date, PoP End, Ceiling Δ, Run Ceiling, Funded Δ, Run Funded, Confidence, and PDF.

• The Document column carries a colored badge — Base Award (green), Modification (blue), or Option Exercise (purple) — so you can see at a glance which instrument each row is.
• Ceiling Δ and Funded Δ show what this document changed (a + sign on increases; negatives render in red). Run Ceiling and Run Funded are the cumulative totals through that row — read them down a contract to confirm the math ties.
• A thicker top border separates one contract from the next; base-award rows are tinted slightly so a contract's starting point is easy to find.

Pinned to the bottom is a TOTALS row showing the portfolio's total ceiling, total funded, and total Unfunded (ceiling not yet funded), plus the row and contract counts.

Step 2 — Filter to what you're chasing

Use the filter bar directly under the header (it re-queries as you change it):

• Contract # (exact) — a text box; type the full contract number to isolate one contract's document trail.
• All documents — dropdown to show only Base Award, Modification, or Option Exercise rows.
• All types — dropdown to filter by contract type (T&M, FFP, CPFF, CPAF, CPIF, IDIQ, HYBRID).
• All entities — dropdown to filter by legal entity when you consolidate more than one under a single accounting tenant.
• All P/S — dropdown for Prime vs Sub.
• All status — dropdown for Active vs Expired.

The right end of the bar shows the live "N rows / M contracts" count for the current filter.

Step 2b — Clear the contracts Arcvue says are incomplete

The register's own button opens Contracts Needing Details, a drawer listing every contract missing something Arcvue needs, with the count beside the title. Work it before you chase anything else: a contract in this list cannot price, and in most cases cannot invoice.

The scope toggle across the top is Active, + Historical and All (incl. Canceled), each with its own count. It opens on Active, or, when Active is already clean, on the first scope that still has rows. If a scope reads "All contracts in this scope are complete," the line beneath names the scope that still has work and takes you there. The drawer stays open after each save, so a list of end dates is worked through in one sitting.

Each missing field is fixed in the row itself, and it saves when you click away — there is no Save button. A money field shows $0 until you type; a field Arcvue already has values for shows Pick existing or type new… and completes against the clients, agencies and capabilities in use on other contracts, so spelling stays consistent without anyone policing it. One field type is different: a forecast-workspace row offers Open Workspace instead of an input and takes you to the workspace, because the value is built there rather than typed.

Verify SCA Designation is a question, not a status. The row reads Currently: Non-SCA (defaulted, not confirmed) and offers Non-SCA and SCA. A contract showing Non-SCA may simply never have been looked at — that is what "defaulted" means here, and Arcvue is telling you so rather than implying a decision. Service Contract Act coverage decides whether wage determination floors apply to the labor on the contract, so answering it is not housekeeping. Answer it from the award document, not from what the row already shows.

The other review a contract can ask for is whether it is still live: Still Active confirms it, and Mark Canceled asks when the contract ended before it hides it from active views.

That date is not bookkeeping — it is the end of performance, and the forecast, the value builder, the waterfall export and past-performance matching all read it in preference to the period of performance. Arcvue fills it in with the end of the awarded period, so a contract that simply ran its term needs no typing. Change it only when the contract was terminated early, and enter the date it actually stopped rather than the day you noticed. The awarded period of performance is left as it was, so the record still shows both what was awarded and that it ended early.

Arcvue asks When did this contract end? and fills the field in for you. Record End Date commits it, and Back leaves the contract alone.

A contract with no period of performance on file is refused rather than guessed: there is nothing to fill in from, so Arcvue asks you for the date.

A contract retired in favor of a live successor is not asked for an end date: the successor is its disposition, and nothing ended on any date.

A contract that is already canceled shows its end date under the All (incl. Canceled) scope, and you can correct it there. The row is labeled End Date, its field is Recorded end date, and it carries the date currently on record rather than a blank — this is the one place in Arcvue that date is visible. Change it and Save End Date writes it. Use period end fills in the end of the awarded period in one click, which is the right answer for a contract that simply ran its term and was marked canceled some time later.

An end date falling AFTER the period of performance is flagged, because a contract cannot stop performing after it has already finished. That flag explains the row; it does not decide which rows appear. Every canceled contract shows its end date, because a date that is merely plausible can still be wrong and nothing in the data marks it.

Step 3 — Check an extraction's confidence and open the source PDF

The Confidence column shows how sure the extractor was about that document, as a small bar plus a percentage. Anything under 70% grows an amber Needs Review chip and the row gets an amber left edge — those are the documents to re-verify against the source before you trust the numbers.

To read the source document, click the PDF (file) icon at the right end of the row. It opens the executed PDF in a new browser tab (via a short-lived signed link). Rows with no stored document show a dash instead.

Step 3b — Name the party on a subcontract document

When the document you are accepting is a subcontract your company issued, a Name the party panel appears above it before you can accept.

Arcvue reads the company's name off the document and then refuses to pick the register entry for you. That refusal is deliberate. The panel prints the name exactly as the document has it — "The document names …" — as a hint, and what the accept actually sends is your choice in the Subcontractor picker beside it.

The reason is worth knowing, because the panel looks like an unnecessary step. A near miss between two similarly named companies would bind the agreement — and every invoice paid under it afterwards — to the wrong payee. A name on a page is not an identity in your register, and only a person can say which entry it is.

Prime contract id is optional, and is likewise typed rather than matched. It records which of your prime contracts the subcontract sits beneath.

If the reader found no name at all, the hint is simply absent and the panel says to choose with care. That is not a failure to accept — it is the screen declining to imply a name it does not have.

If nothing is on file yet, the panel says so in amber and names the step to do first: add the company on the Subcontractors screen. It does not leave you looking at an empty picker wondering whether something is broken.

Once you accept, the panel turns into the pointer to what it created — the agreement number, and a link into Procurement, where it is now listed under subcontract agreements.

Step 4 — Drill into a contract for funding, PoP, CLINs, and rates

Who is in charge sits under the funding status: the Program Manager(s) assigned the contract, the lead of the division it sits in, and the tenant's Operations Lead, read from the same assignments that put the contract in their My Programs. Past-due receivable alerts go to these people in that order; a contract showing nobody is one whose alerts reach only the COO, and the fix is the user's contract scope, not this screen.

The register is read-only, so when you need the full picture — burn against funding, option-period detail, CLINs, key personnel, alert history, and the LCAT/milestone billing terms — open the contract itself. Go to Contracts → Contracts (/accounting/contracts), click the contract, and you land on the detail page (/accounting/contracts/:id).

That list is its own screen with its own filter bar — not the register's. It opens on All statuses and All alert states, and the alert filter narrows to Open funding alert or No funding alert, which is how you get from something is wrong somewhere to the rows that have it. Reset clears everything back. Open checklist takes you to that contract's closeout checklist.

Funded vs Ceiling is a bar rather than a figure, so a portfolio's shape reads at a glance. And each row carries its funding alert as a badge:

Badge	Means
75%+	funding consumption has passed three quarters
90%+	past ninety percent
FAR 52.232-22	the limitation-of-funds clause applies

The detail page shows the FAR 52.232-22 banner for one contract; the list shows the same signal for all of them at once. That is the view to start from when you are asking which contracts need funding attention, rather than opening them one at a time.

The detail page is split into eight tabs — the Contract sections strip under the header — so no one section pushes another off the screen:

Tab	What it holds
Overview	funding status (an ordering vehicle says its funding lives on its orders), period of performance, key personnel, and the alert history
Billing	CLINs, the roster with its LCAT assignments, and the billing terms
Invoice	the invoice designer, and Propose Invoice Lines, a dry run of the billing engine for a period
Revenue	the recognition election, recognized revenue, award fee, and the EAC
Hours	the hours budget: hours given to each person on each line for the contract year, against the hours they have used, with each person's days and a monthly workbook. Its Program Manager and Division Lead reach the same panel from Hours on My Programs; the manager guide Hours Budget walks it
Documents	the contract documents attached to this contract, plus a count of uploaded documents not yet attached to any contract
Ledger	the ten most recent postings Arcvue has booked against the contract; activity carried over from the books kept before Arcvue feeds the Overview figures but is not itemized here
History	every recorded change to the contract, grouped by day, with who made it and the reason given — closing or reopening a contract requires one, so this is where that reason is read back. A change Arcvue made on its own reads Arcvue (LLM automated); every other entry names the person at your company who made it

A link that lands on a particular tab carries it in the URL (?tab=billing), so the tab survives a refresh and can be shared; the unpriceable-hours badge on the contract list opens Billing, where the assignment is made.

Key personnel + metadata is edited in place. Edit opens the fields — Contracting Officer or Equivalent (on a subcontract, the prime contractor's point of contact, since a subcontract has no contracting officer), COR and their contact details, and Set-aside, whose blank choice reads Not stated — and Reason (optional) lets you say why the record is changing. Each field carries a small help button beside its name that says what the field is, where its value comes from, and how to correct it. Save stays disabled until something has actually changed (the panel says Nothing has changed yet.), Cancel discards the edit, and every saved change lands in the contract's change log with who made it.

On the detail page you'll see:

• Funding status — funded value, burn to date, remaining, % consumed, a color-coded progress bar, and (when applicable) the FAR 52.232-22 limitation-of-funds banner at 75% consumption.
• Period of performance — base dates, award date, and an Option periods table showing each period's ceiling, funded amount, and whether it's Exercised.
• CLINs — CLIN, Type, Period start, Period end and Funded. This is the summary; the full table, with the Basis column that says which rows are waiting on you, is on the Billing tab and is described below.
• Key personnel + metadata, Funding alerts, Documents, and Recent GL activity — the GL table reads Date, Account, Debit, Credit and Description, with the unused side of each row left blank rather than printed as zero.
• Transaction coding — normally quiet, but it changes color and states so when automatic coding is off for this contract, because that is a fact you need before you go looking for entries that were never going to appear.
• Contract status — says whether this contract is open or closed, and carries the control that changes it (Step 6b). A closed contract leaves the active-contract lists and pickers; it does not stop invoicing.
• A panel whose data fails to load says so and offers Try again rather than rendering empty.
• At the bottom, the Labor Categories table (billing rates per LCAT) and Billing Milestones — the terms invoicing reads. This is where rate correction starts (Step 5). Each labor category row shows its Rate, Hours billed, Ceiling hours (the hours the document states for that line) and Ceiling $ (those hours at the rate — the document's extended value; blank when the document states no hours), with its Status.

Propose Invoice Lines — on the Invoice tab, beneath the designer. Pick a Period start and Period end and press Compute proposal: the billing engine returns the lines an invoice for that period would carry — Type (hours at a labor category, or a milestone), CLIN, Description, Qty, Rate and Amount — and their total. Hours come from both sides of the contract: your employees' timesheets, and the hours your subcontractors' staff recorded in the Subcontractor Portal, each priced at the contract's rate for the labor category the person is staffed on. A subcontractor's hours are priced only once approved. It is a dry run and creates nothing; generating the invoice is a separate step on the same tab.

Planned billing spread — shown on a contract's Billing tab when the contract bills on rates and quantities and its award carries a payment schedule. The rows are the award's planned spread of the price over the period, listed by Date, Line (the schedule line the award names) and Amount. It is read-only by design: nothing in it is waiting to be invoiced, there is nothing to complete, and invoicing on such a contract is never driven from it. On a fixed-price contract the same schedule appears under Billing Milestones instead, with its status control, because there the schedule is what the invoice engine bills.

The CLIN table on the Billing tab — the reference the invoice is built from

Every invoice line prints a CLIN's funded and remaining balance, so a wrong figure here is printed, sent and paid against. Arcvue proposes the table from the award and every modification; this table is where you read how each figure was established and settle the rows that need a person.

The columns are CLIN number, Description, How it bills, Funded $, Ceiling $, Fee, Period start, Period end and Basis.

Basis is the column the table exists for, and it is the only one that carries color. A row that needs nothing from you is quiet. A row waiting on a person is colored and carries the control that answers it, so you can work the table by looking only at what is not gray.

Basis reads	What it means	Waiting on you
Read from the document and matched by a second reading	two independent readings of the award agreed on the figure	no
Confirmed	settled	no
Confirmed by an operator	the figure is a person's, not a document's, and the date says when	no
No funded amount stated on any document yet	nothing has stated an amount, so there is nothing to check — not an error	no
Needs your confirmation — one reading of the document, nothing to check it against	one reading only, with no second reading to corroborate it	yes
Two readings of the document disagree	the two readings conflict, and the figure shown is the document reader's	yes
Held — a later document states a different amount	a modification states a different figure, quoted underneath the sentence	yes

The last three are a working queue, not a hypothetical state — rows sit in them on live contracts, and they sit on the path to an invoice. Clearing one is reading the award and saying which figure is right.

How it bills is the pricing basis, and it is one of T&M — hours × rate, FFP — fixed price or CPFF — cost plus fixed fee. A row can arrive with none of them: a modification on a hybrid award sometimes states a line without saying how it bills. Nothing invoices against a row until somebody chooses, so an unanswered basis is a stopped invoice rather than an untidy table. Edit opens a row for change and Cancel discards it.

Only a CPFF row carries a Fee, stated either as a percent of cost or as a fixed amount. The invoice engine refuses to draft a CPFF invoice while no CLIN states a fee, which is the same point again: the blank is not cosmetic, it is what is holding the invoice.

State a CLIN is for a line the documents have not produced — you can leave How it bills on Choose later, and Create the stated CLIN saves it. It lands as yours: the row's Basis will say a person set it. That is deliberate, because the table never presents a human's figure as something a document said.

The roster on the Billing tab, and the category an employee bills under

You cannot add or remove anybody here, and that is deliberate. The roster is derived from timekeeping — the people with an active assignment on this contract, plus anyone who has charged to it recently — so it is never a hand-kept list that can drift from who is actually working. If somebody is missing, the answer is in timekeeping, not on this screen.

The columns are Name, Labor Category, On roster via and Last charge. On roster via says why each person is on the list:

Reads	Means
Assigned	they have an assignment on this contract
Charging	they are charging hours to it with no assignment
Assigned + Charging	both — the normal, settled state

Charging is the one to act on. It means hours are landing against a person whose billing category nobody has stated.

The one thing a person states on this screen is the labor category an employee bills under on this contract. That choice picks the negotiated rate out of the contract's own labor-category table — the rate is never typed here — and until the category is stated, that employee's T&M hours cannot be priced. A blank category is a held invoice, exactly like a CLIN with no pricing basis.

Assign or Change opens an inline editor: Choose a category, an Effective date, and a Reason. Before anything is written it tells you how many already-logged hours the move re-prices and by how much the invoice changes, so a back-dated category change is never a blind edit — and it says so up front rather than after you commit. Cancel discards it. A move the period will not accept says why instead of failing quietly.

Arcvue proposes a category for anyone charging without one, refreshed nightly; a contract with nobody waiting shows nothing. On a proposal:

• Accept takes it as the employee's category from the effective date shown. A proposal that cannot be accepted yet says why, naming the period's state.
• Not this opens a short explanation field, and Decline stays disabled until you have written something — a proposal cannot be dismissed silently, because the reason is what stops the same suggestion coming back. Keep it backs out of declining without deciding.

When an option year is exercised, the assignments follow — the rates do not. Accepting a modification or exercising an option that moves the period of performance forward carries the labor-category assignment windows forward with it, so people do not silently drop off the billable list when a period rolls. It is deliberately selective: a window that ended with the old period follows the new one, for anyone who charged the contract in the ninety days before it ended. A window you ended stays ended, and so does one belonging to somebody who had already stopped charging — the rollover extends what the calendar closed, never what a person closed.

The negotiated rates do not roll, and that is the half to act on. A rate is a fact from the executed document, so nothing invents one for a period the document has not priced. When no active rate covers the day after the old period end, the accept writes a line into the contract's change log at that moment, and it names the remedy: load the exercised period's rates from the executed document — Section B, or the modification itself.

Why that line matters more than it looks. Hours in a period with no rate price to nothing, and when that happens the invoice, the revenue and the unbilled AR are all short by the same hours — so everything still balances and nothing downstream fails. The change-log line at the accept is the signal; there is not going to be a second one.

Automatic coding, and the two controls that toggle it

Arcvue codes this contract's transactions for you until you tell it not to. The control is one button that swaps label with the state:

It reads	Meaning
Turn off automatic coding	Coding is on. Pressing it asks Turn off automatic coding for this contract? before anything changes.
Resume automatic coding	Coding is off. Pressing it turns it back on.

So the button tells you the state you are in, not the state you are going to — if it reads Resume, automatic coding is already off and nothing is being coded for this contract right now.

Assigning a labor category

On the roster, Assign labor category commits an LCAT to a person and reads Assigning… while it saves. The LCAT decides which billing rate the invoice engine uses for that person's hours, so it is a billing decision wearing a staffing label — see the rate rules above before changing one.

Saving an edit on the contract

Edits on the detail page collect until you press Save changes, which reads Saving… while it writes. Nothing on this page saves as you type.

Step 5 — Correct a billing rate the sanctioned way

Billing rates are read-only wherever they appear. The Labor Categories table on the contract detail page says so directly: "Source: contract document (Section B). Billing rates are extracted from the executed contract and are not editable here. Flag a rate error to queue the contract for re-review." Correcting a rate is a two-part flow, and it never involves typing a new rate over the old one in a grid.

Part A — flag the wrong rate. On the contract detail page, in the Labor Categories table, find the LCAT row and click flag rate error (right-hand column, active LCATs only). A prompt asks for a note — enter which field is wrong and what it should be. Submitting queues that contract for re-extraction review. This creates the audit trail; it does not change the rate.

Part B — correct the document in the review queue. Go to the Contract Documents queue: from Contracts → Contracts, click the Upload & review proposals link (top-left, under the "Contracts" title). The header reads Contract Documents — "AI-extracted contract documents pending human review." Each row shows Contract #, Counterparty (the agency on an award, the subcontractor on a subcontract you issued), an Action badge, Confidence, Status and the Extracted date.

1. If the correct rate lives in a document Arcvue hasn't ingested yet (an amended Section B, a re-issued pricing schedule), click Upload PDF (top-right) and pick the PDF. Extraction runs (~30s) and a new row appears, sorted lowest-confidence first.

2. Click the document's row to open the review drawer on the right. It shows the Document type, Action badge (Award / Modification / Option Exercise), Confidence, Status, and any Validation warnings.

3. In the Extracted fields table, the correctable fields render as inline inputs while the document is Pending. Edit the field(s) you need to fix; each field you touch gets an amber border so your changes are obvious. (Note: nested collections like the LCAT list itself, CLINs, and milestones are not inline-editable in this drawer — for a wholesale rate-schedule change, upload the corrected schedule document rather than hand-patching one field.)

4. Cross-check against the FP&A comparison panel below the fields — it flags each value as match, mismatch, FP&A empty, or extractor missed so you can see exactly where the extraction and the existing record disagree.

5. Click Accept with N correction(s) (the amber button that appears once you've edited a field). Arcvue writes your corrected values through the single sanctioned writer, records who reviewed it, and stamps the status Modified. Downstream billing (the E32 invoice engine) now reads the corrected rate.

6. If the document could belong to more than one contract, accepting opens a choice: link it to an existing contract, or create a new one.

   tip

   Cancel here does not reject the document — it leaves it Pending. "Decide later" is a real answer, and the dialog is built so you can give it: a document that belongs under neither candidate is a case that actually happens, and forcing a pick just to close the dialog is how a wrong link gets recorded. Come back when you know.

note

The plain green Accept button is disabled the moment you enter any correction — that's intentional. Accepting with corrections is a distinct, logged action so the edit is never mistaken for a clean approve. If the extraction is perfect and every field agrees with FP&A, use Auto-accept matches instead (enabled only when it's safe).

Step 6 — Keep modifications and option exercises current

A modification with no effective date shows Set a date in that column rather than an em dash. That is a control, not a placeholder — clicking it opens the effective-date dialog. The em dash means the column does not apply; Set a date means it applies and nobody has supplied it.

When a mod or option exercise happens, get its document into the Contract Documents queue (upload → review → accept), same as Step 5 but choosing Accept for a clean extraction. Option exercises especially: they extend the period of performance and add the period's funding. Until the document is accepted, the register's Run Funded and PoP End for that contract are stale — and so is everything downstream that reads them.

---

Correcting the date a modification takes effect

When a modification was keyed with the wrong effective date — the SF-30 says 1 March and somebody typed 10 March — you correct it from the register rather than re-entering the modification.

This is not a cosmetic date fix. A modification's effective date is part of how a rate version is identified, so moving it can change which billing rate applies to which period. That is why this dialog spends most of its space telling you what the move would do, and why you should read that part rather than the date field.

You say why first, then you see what it costs

Two fields: New effective date, and Why it is moving. Both are required before Arcvue will work anything out — the preview does not appear until you have filled in both, and it re-runs as you change either one.

That order is deliberate. You state what you are correcting before you see what the correction does, so the reason is your own rather than something written to fit the outcome. It is recorded against your name in this contract's change log.

The rate itself is never changed here — only the date it takes effect. If a rate is wrong, Step 5 above is the sanctioned path and this is not it.

Read "What this changes" before you commit

The panel shows the old date and the new one, then how many rate versions move with the modification and on which CLINs. If nothing hangs off the modification it says so, and only its own date moves.

And if the move would reorder the rate chain, an amber block says "This resequences the rate chain" and lists the changes in sentences. Read those sentences. They are written by the part of Arcvue that can see the whole chain, and they are the only place the reordering is visible — a count of rate versions is true and tells you nothing about the sequence.

The refusals, and what they mean

• "That is already the effective date. Nothing would change." The commit button stays unavailable. This is not a failure; there is nothing to do.
• A refusal in the panel — most often a collision with a rate version that already occupies the date you picked — is the answer to your question, not an error to retry. It stays on screen so you can read it, and it changes when you change the date.

Cancel closes without writing. Re-date modification commits, and it becomes available only once there is a real change, a reason, and a preview that did not refuse.

Base awards do not have this

The register offers this only on modifications and option exercises. A base award's effective date is a different field entirely, kept with the award itself, and it is not corrected from here.

---

Step 6b — Close a contract when the work is finished

The control is one button carrying the opposite of the current state: it reads Close contract while the contract is open, and Reopen contract once it is closed. Read it as the action available, not as the status — a contract showing Reopen contract is closed.

A contract's period of performance ending is not the same as the contract being closed, and Arcvue keeps the two apart on purpose. A period can lapse while a final invoice is still to go out, and an option can be exercised on a contract whose dates have run out. So closing is something you say, not something the calendar decides.

On the contract's page, the Contract status card says which it is. While the contract is open the card reads This contract is open and offers Close this contract; once closed it reads This contract is closed and offers Reopen this contract. Both ask you to confirm, and both ask why.

What closing does. The contract leaves the active-contract lists and pickers, the incurred-cost submission schedules, and the funding and rate-revision sweeps. It stops being something Arcvue offers you as current work.

Closing also ends time charging to it the same day. Every open charge authorization on the contract ends today, recording who closed it and why; one that had already ended keeps its own end date, and nothing is deleted. The contract's change log records how many were open before the close. The contract leaves everyone's time-entry pickers even if an authorization outlives the close, and a charge to it is refused, telling a person who held an authorization that the contract is closed. Reopening does not restore those authorizations — if work resumes, grant charging again, so each return carries a name.

What closing does not do. It does not stop invoicing. A closed contract can still raise its final invoice, and nothing already posted changes. Closing is a portfolio decision, not a billing control — if you want to stop billing a contract, that is the billing schedule or the rate card, not this.

Why? — the confirmation asks for a reason in your own words, and will not let you continue without one. Final invoice paid, closeout complete is a reason; a blank box is not. The reason, your name and the time go onto the contract's change record, which is what answers an auditor asking why a contract stopped appearing in the active list. The neighboring coding-mode switch has no such field and says so in its own dialog; this one does, because closing is the more consequential of the two.

Why did it close? — on a close, the confirmation also asks what kind of ending it was, from a list that opens on Choose one: Completed, Expired, Terminated for convenience or Terminated for default. It will not continue until one is chosen. The kind goes onto the change record as its own line, the Contract status card reads it back beside This contract is closed, and a termination for convenience adds a termination settlement proposal item to the contract's closeout checklist. A contract closed before this existed can be closed again with the right kind: nothing else changes and only the kind is recorded.

Reopening works the same way and also asks why; it clears the kind. Both the close and the reopen stay on the record, so a contract that was closed and reopened does not read as though nothing ever happened.

---

Step 7 — Elect how a contract recognizes revenue

Ask Arcvue to propose reads the contract document and suggests an election; it reads Reading the contract… while it works. A proposal is a suggestion and writes nothing until you record it.

The record button tells you whether you are replacing something. With no election on file it reads Record the election; once one exists the same button reads Record the new election. If you see the word new, an election is already in force and you are about to supersede it.

On a contract's page, the Revenue recognition method card leads with the truth for that contract: the method in force and since when, or recognized on the billing schedule for August with no method elected, or nothing recognized yet. The recognition run does not wait for you — an unelected contract recognizes on a default rule — but a default is not a decision an auditor can read, so elect one.

Under How does this contract earn its revenue? pick a measure; the card offers only what the contract's shape allows (an hourly contract: Right to invoice; a fixed-price contract: Billing schedule, Straight-line over the funded period, Cost-to-cost, Labor hours, or Milestones, at acceptance) and preselects what the run would use. Set Takes effect from — the first month the conclusion governs; it defaults to the earliest open month and cannot be a closed one, because a closed month is never re-derived. Write Why this method in your own words. Click Add a clause for each piece of contract language the conclusion rests on and quote it; Remove takes a row out. For Labor hours only, enter Total hours estimated and Where the hours estimate comes from. For a contract awarded before Arcvue kept its books, enter Revenue recognized before Arcvue and the month it is Recognized through, so a cumulative method starts from the truth. Click Record the election.

The card then shows the method, from which month, your reason, the clauses, who elected it and when, and whether it is Locked (a period has posted under it) or Open. Change the method records a new election from the month you state; the earlier one stays beside it, every month keeps the answer it was recognized under, and a cumulative method books its catch-up in the first month it governs — negative when the old method ran ahead. Elections are append-only. A hybrid contract or an ordering vehicle carries no election, and the card says why.

Arcvue may have proposed one already

You do not always start from a blank card. Where Arcvue has read the contract document it proposes a method and shows its reasoning: the clauses it relied on, quoted with their references, and a short list headed What the document leaves open.

Read that list first. It names what the paper does not settle — and those are precisely the points the election is your judgment rather than the document's. A proposal that raises two open questions is not a weaker proposal; it is one telling you where to look.

Use this proposal loads the method, the reason and the clauses into the form below, where you can change any of it — nothing is recorded until you click Record the election. Set it aside dismisses the proposal and leaves you to author the election yourself; it does not reject the document or change anything on the contract.

(The clause text box is announced to assistive technology as What it says.)

Step 7b — Declare how each CLIN measures earned value

Where Arcvue has extracted CLINs from the document, Confirm as shown accepts them exactly as extracted and reads Confirming… while it saves. Create CLIN adds one by hand, reading Creating… while it works — use it for a line the documents did not produce.

warning

This is not the same decision as Step 7, and the two are easy to merge. Revenue recognition method is contract-grain and answers how this contract earns its revenue. CLIN Earned Value Techniques is CLIN-grain and answers how progress credit is computed — which drives invoices and EVMS reporting. A contract has one of the first and one of the second per CLIN.

EIA-748 requires each CLIN to declare how earned value is measured. The table lists CLIN, Type, Period, Technique and Behavior, and every CLIN starts on Percent Complete unless you change it.

Technique	What it does	Where it fits
Percent Complete	the PM enters a physical percentage each period; earned value is the budget times that percentage	engineering, software, most discrete work — the default
0/100	no credit at all until the deliverable is finished	short milestones — a document, a test event
50/50	half the credit when work starts, the rest on completion	work whose mid-point cannot be measured objectively
Level of Effort	earned value always equals planned value	ongoing support with no discrete deliverable — PM, QA

Level of Effort has a consequence worth reading twice: because earned value always equals planned value, no schedule variance can ever be shown on that CLIN. It will never report as behind, which is correct for genuine level-of-effort support and hides a real problem anywhere else. Choose it last, not first.

Step 7c — Record the contracting officer's award-fee score

A cost-plus-award-fee contract shows an Award fee card under the recognition election. It names the tenant's estimation policy (elected on the revenue policy page), the estimate the recognition run has posted under it, and every score recorded with the invoice that billed it. When the contracting officer's letter arrives, set Evaluation period from and to, enter the Scored fee (USD), and write the Note (the letter, the score, anything the file should say) — that note is the audit trail beside the number, so a score recorded without one is a figure nobody can source later. Then Record the score; the next invoice for the contract bills every unbilled score whose period has ended, and the run reverses its estimates in the period the fee bills. A score is a record: a period already scored is refused, and a correction from the CO is recorded as its own period.

The rate table, and proposing a period's lines

The billing rates on a contract show as CLIN, LCAT, Rate, Hours Billed, Ceiling and a status of Active or Inactive. A rate that has gone inactive stays on the table with its hours rather than disappearing, so a period billed under an earlier rate still reconciles.

Propose Invoice Lines takes a Period start and Period end and returns what is billable in that window: Type, CLIN, Description, Qty, Rate and Amount. When there is nothing it names the window it looked at — so an empty result tells you which dates were searched, which is the difference between nothing happened and you asked about the wrong month.

Step 7d — Read what the election actually produced

Once a contract carries an election and a close has run, its detail page shows a Revenue and receivables panel. It answers one question — what this contract has earned, against what has been invoiced — and the gap between those two is your unbilled receivable.

Three figures sit across the top:

• Recognized to date — revenue earned on this contract.
• Earned, not yet invoiced — unbilled AR.
• Invoiced, not yet collected — billed AR.

The recognition method you chose at Step 7 is printed underneath them, so you can see which rule produced the number without leaving the page.

A figure that reads Not configured is not a zero, and that distinction matters more than any number on this panel. Arcvue measures the two receivable balances from the account roles configured for the contract's legal entity. Where a role is not set, there is nothing to measure — so the panel says so rather than printing $0.00. A zero would look like a real, settled balance, and on screen it would be indistinguishable from one nobody ever measured. The fix is to configure the account role for that entity, not to go hunting for the contract's missing money.

The period table shows movements, not balances

Below the figures, one row per accounting period: Period, Recognized, Unbilled change and Billed change.

The last two columns are changes within that period — not running BALANCES. Reading the bottom row of Unbilled change as what is unbilled today is wrong by every period above it. The balances are the three figures at the top of the panel; these columns are one month's movement each.

An empty panel and a failed panel mean opposite things

Nothing recognized yet is an answer. Arcvue looked, and this contract has no posted recognition. Recognition proposes draft entries at month-end close and they reach this panel only once a controller posts them — so on a contract that has plainly been earning, this nearly always means the entries were proposed and never posted, not that nothing was earned. Go back to the close and post them.

Revenue could not be loaded for this contract is the opposite: Arcvue is declining to answer. A reply that arrives in a shape Arcvue does not recognize is treated as a failure rather than as an empty result, because showing an empty result there would read as a settled zero on a contract that may be carrying millions. Reload the page; if it persists, the recognition data has not landed and the panel is right to refuse.

Part 2½ — What the invoice looks like (set it once per contract)

The same invoice goes out every month for the life of a contract, so its shape is something you set up once rather than re-decide each period. Open a contract and use the invoice designer: pick a format, adjust it for this customer, watch the contract's real latest invoice redraw as you go, and save it.

Facts are turned on and off one at a time. A fact currently on the invoice sits in the list plainly; one that is off is shown struck through with + add beside it, so the list is a record of everything available rather than only what you picked. Once you have changed anything, Save to this contract keeps it for this contract alone — and Save as a new format…, which appears only once there is something to save, asks for a name and makes the result reusable elsewhere. Choose the second when the layout is a customer's house style rather than this contract's quirk.

Nothing in the designer changes an amount. What is billed comes from the contract documents and the timecards. This decides how the page is laid out — where the facts print, which facts, in what order, and which columns appear. If a number is wrong, the designer is the wrong tool; see When something looks wrong below.

The five standard formats

Every tenant has these without setting anything up, and the one your billing type suggests is marked when you open the picker:

Format	For
Time and materials	labor billed by hours and rates
Fixed price, monthly amount	a fixed amount each period, no hours or names
Fixed price, deliverables and milestones	billing on deliverables
Cost reimbursable voucher	cost-type vouchering
Whole contract, one line	the entire contract billed as a single line

The suggestion follows the contract: T&M suggests Time and materials; a fixed-price contract suggests Fixed price, monthly amount when it has a periodic schedule and Fixed price, deliverables and milestones when it does not; cost-type suggests Cost reimbursable voucher. It is a suggestion — pick whatever the customer actually wants.

note

On a contract nobody has configured, the designer prints "Nothing is saved yet — the format shown is the one this contract's billing type suggests" in amber. That is not a warning that the invoice is wrong. The suggested format is what the contract already bills with, and per the next section it is usually the right one. Saving does not change the output — it records the decision, with your name against it in the change log, so the layout is answerable later. A contract can be left unsaved indefinitely and still invoice correctly.

An unconfigured contract is already right, and that is measured

The defaults are not a convention somebody chose; they are this tenant's dominant invoice shape, taken from a month of its own invoices. Most contracts need no adjustment at all. The designer exists for the customer who wants something different — a purchase order number on the face, the facts in another order, no hours shown.

Who the invoice is addressed to

The designer opens with Bill to: the customer's name (the client on the contract record), the Attn line (the contract's COR), and the postal block that prints beneath them on every invoice for this contract. The name and the Attn line follow the record; correct them there. The postal block is typed here — one line per line of the address — and Save address writes it to the contract and redraws the preview; Cancel restores what was saved. Each change is logged with who made it, and the block shows who last set it (Arcvue (LLM automated) when Arcvue set it on its own). A block that would not fit the page is refused with the limit named (eight lines, eighty characters a line).

The three lines come from three different places

The Bill To block on an invoice is three things stacked, and only the last of them is typed on this screen:

line	where it comes from
the customer's name	the client on the contract
the Attn: line	the COR on the contract
the postal address	typed here, in Bill To address

So a wrong name or a wrong Attn line is not fixed here. Both are contract data — correct them on the contract and the invoice follows. Typing a correction into the address box puts the right words in the wrong place.

If there is no Attn: line, the screen tells you why: the contract has no COR yet. That is a contract-data gap with a named cause, not a blank to work around.

Saving, and what an empty box means

Bill To address takes the street and city lines as you want them printed. Save address writes it and confirms that every invoice for this contract prints it; Cancel drops what you typed and puts the saved block back.

Saving an empty box is a change, not a non-change. Arcvue confirms it in those terms — invoices will print the customer's name alone. Clearing the address is the right move when the customer genuinely has no block to print, and the wrong move if you only meant to start over — that is what Cancel is for.

Once saved, the screen records who set it and when, so a block nobody recognizes has an author.

A half-typed address cannot land on the wrong contract

An address you have started typing belongs to the contract you typed it on. Move to another contract and you see that contract's saved block, not your unfinished draft — so an edit interrupted halfway cannot be saved onto a customer it was never meant for.

What you can adjust

The contract facts block can sit in one of two places, and the two buttons name the position they select, not the one you are in: Right of Bill To and Left, below Bill To. The one currently in force is the one shown as pressed.

The designer labels its controls as plain sentences rather than as setting names, so what follows is what you will actually read on screen.

How the lines are grouped

• One line for the whole contract instead of a task per CLIN — off by default, which bills a task per CLIN. Turning it on reveals What the line says, because the single line needs something to call itself.
• Print the number without the word CLIN in front of it — off prints CLIN 0001; on prints 0001.

What each line shows

• Inception to date column — a second amount column carrying the total billed since the contract began, on every line and every total.
• Hours and rate columns — turn off for fixed-price lines that carry an amount and nothing else.
• People's names on labor lines — the person beneath their labor category.
• Heading above labor lines — clear it to suppress the heading entirely.

Funded values

• Funded and remaining at the top — the contract's funded value and what remains, printed once above the tasks.
• Funded value on each task — each CLIN's own funded value under its task heading.

The facts block and the footer

• Which facts print, in what order, and where the block sits — invoice number, invoice date, billing period, payment terms, due date, contract number, order number. Remove takes one out; Add a line adds one of your own.
• Custom facts are your own label-and-value pairs. This is where a customer's purchase order number goes, and it is the reason most customers no longer need a code change.
• Note at the bottom — printed after the remit line.

tip

Two of these are really one question: what kind of contract is this? People's names on labor lines and Hours and rate columns both belong on a T&M invoice and usually do not belong on a fixed-price one, where the line carries an amount and nothing else. Decide the contract type first and the two toggles answer themselves — which is also why the format is set once per contract rather than per invoice.

Preview, then save

The preview is not a mock-up: it redraws a real invoice from this contract with your unsaved settings, so you are looking at the real document before you commit to it.

Drawing chooses which invoice that is. It lists this contract's invoices by number and period end, and it only appears when there is more than one to choose between. Leave it on Most recent with detail and the preview takes the newest invoice that actually has lines on it; pick a specific one when you want to see how a particular month prints, which is usually why you are here.

Invoices carried over from a previous system are headers only -- they record what was billed, not the lines behind it. The preview skips those, because a correct format drawn around an empty table looks like a broken invoice. If a contract has nothing else, the preview says so and tells you to generate one for a billing period rather than drawing nothing.

Then choose:

• Save to this contract — every future invoice for this contract uses it.
• Save as a new format — give it a name in New format name and it joins your own format library, one click for the next customer who wants the same thing.

Discard changes abandons everything unsaved and puts the designer back to the format as stored — worth knowing before you experiment, because the preview tempts you to.

Every save is change-logged with who made it, which is what makes a layout question answerable months later.

Your own format library

Save format stores the current design as a reusable format and reads Saving… while it writes. It saves the format, not the contract — the design becomes available to other contracts, and the contract you are standing in keeps whatever format it was already assigned until you assign the new one.

Named formats you save live alongside the five standard ones. A format cannot be deleted while a contract still bills with it — the refusal is deliberate, so a cleanup cannot silently change what a live contract prints next month.

Part 3 — When something looks wrong

Symptom	What it means	Fix
An invoice or recognized-revenue number is off	Start with the contract's facts — usually the root cause is here.	On the register, filter to the contract and check its Type (drives billing/recognition method), Run Funded for the current period, and PoP End. A stale option-year funding or an unextended period is the most common cause.
A billing rate is wrong but I can't edit it	By design — rates are read-only everywhere.	On the contract detail page's Labor Categories table, click flag rate error and note the fix, then correct the underlying document in Contract Documents and use Accept with corrections (Step 5).
A contract's period looks too short / an option isn't reflected	A modification or option-exercise document hasn't been accepted yet.	Upload and accept the mod/option document in Contract Documents; the register's Run Funded and PoP End update once it's accepted.
A row has an amber "Needs Review" chip	The extractor's confidence was under 70% for that document.	Click the PDF icon to open the source and verify the extracted figures; correct any wrong field via the document queue.
Running totals don't tie across a contract's rows	A Ceiling Δ or Funded Δ was mis-extracted, or a document is missing from the trail.	Read down the contract's rows against the source PDFs (PDF icon per row). Correct the offending document's fields in Contract Documents, or upload the missing mod.
A contract I expect isn't in the register	Its award document was never accepted — extraction alone doesn't create the record.	Open Contract Documents, confirm the award is uploaded and Pending, then review and Accept it. Accepting writes the contract row and unlocks downstream modules.

---

One-line summary

The Contract Register is the flat, audit-ordered ledger of every contract document and the running ceiling/funding they roll up to — the source of truth invoicing, revenue, and closeout all read. It's read-only: contract terms come from the executed documents (uploaded and reviewed in Contract Documents, not typed in), billing rates are corrected only by flagging the LCAT and re-accepting the document through the single sanctioned writer, and keeping mods and option exercises accepted here is what keeps every downstream number right.

Related

• Review and accept extracted contract documents → Contract Documents (/accounting/contracts/proposals)
• Funding, CLINs, and per-contract billing terms → Contract detail (/accounting/contracts/:id)
• How billing rates feed invoices → Indirect Rates and the invoice engine guides
• What a GovCon close covers → Close a Month (Period Close)