Clauses

A clause is a piece of wording you maintain in one place and pull into as many templates as you like — a signing block, a costs disclosure, a confidentiality paragraph.

A clause is a Word document, exactly like a template. It is versioned the same way, shared the same way, and edited in the same designer. What makes it a clause is that it is meant to be referenced rather than assembled on its own, and that it lives in its own library so you can find it.

Creating one

1. Open Clauses and choose New clause.
2. Drop in a .docx, or click to browse. Only Word documents are accepted, up to 25 MB.
3. Give it a name. If you leave it blank the file name is used.
4. Create clause — you land straight in the designer with the body open.

Mark it up exactly as you would a template: merge fields, conditions, repeats. Everything the document designer does works here, because a clause is a document.

Categories and finding things

On the Versions & sharing tab you can give a clause a category and a short description. The category becomes a filter on the library, and the description shows beneath the name so you can tell two similar clauses apart without opening either.

Both are part of the version, not separate settings — so restoring an earlier version restores the category it had at the time.

Two things worth knowing about finding clauses:

• Search matches the name, anywhere in it, and ignores case.
• Category filtering applies to the clauses on the current page. The library is paged, and the filter narrows what is loaded rather than searching the whole library. If you are looking for something specific, search by name.

Publishing, and why it matters more here

A clause has a draft and a published version, like any artifact. The difference is what publishing means: every template that references this clause picks up the published version immediately. There is no separate step to push the change out, and no version pinning.

That is deliberate — it is what makes a clause library worth having — but it means publishing is the moment a change reaches real documents. Until you publish, your edits are yours alone.

Anyone you have shared the clause with sees the published version only. Your drafts stay private to your organisation.

Referencing a clause from a template

1. Open a template and go to the Syntaq tab in the ribbon.
2. Choose Insert Doc.
3. Click Browse… and pick your clause.
4. Add to document.

The reference is inserted as an ordinary Insert merge field — the same construct Syntaq has always used for pulling one document into another. Nothing new is added to your markup, so a template using a clause is still an ordinary Syntaq template.

Only published clauses appear in the picker. A reference has to resolve to a published version, so offering an unpublished one would create a link that cannot be followed.

Variants

If a clause needs to say different things in different circumstances — an individual party versus a company, one jurisdiction versus another — write those as conditional content inside the clause body, using the same IF conditions you would use anywhere else in a template.

There is no separate variant editor, and that is on purpose: conditions are already understood by the assembly engine, so a clause with variants behaves exactly like any other conditional document.

Before you edit: what uses this clause

Open a clause and the What uses this clause panel tells you what a change would reach — every template and clause in your organisation that references it, by name, plus a count for any organisations you have shared it with.

This matters because an edit is not local. Publishing a clause updates every template that references it, immediately, with nothing pinned to the old version. The panel is what turns that from a hazard into a decision.

Read the wording carefully when it says "at least". If a document could not be read — an unusual construct the extractor does not handle, or one not yet processed — it cannot appear in the list, so the number is a floor rather than a total. The panel says so when that is the case, and tells you how many of those documents are yours, because those are the ones you can do something about.

Documents in other organisations are counted, never named. You granted them access and can see the grants on this page, but their documents are theirs.

One real limit. A field referenced solely inside a hand-written script cannot be found, so a clause used only that way will not appear. That is a limit of reading the document, not of the panel.

Documents are read the moment you publish them, so the answer keeps up with your library on its own. Anything published before this feature existed is read once, in the background; until that has happened for a given document the panel counts it as not yet read and says so, rather than quietly leaving it out.

Retiring a clause

Archive removes a clause from the library. It is not a delete: anything already referencing it keeps working, existing shares are untouched, and it can be restored.

What is not here yet

Stated plainly so you do not go looking:

• Sharing controls. You can see who already has access on the Versions & sharing tab, but granting and revoking access is not built yet.
• Seeing a reference resolve. Document assembly is not part of Kestral yet, so you can insert a clause reference but not watch it expand into finished output.