Legal · stage 5 of 5

Execute

Await gate

Finalize documents and coordinate signatures

Execute

The closing stage of a legal matter: incorporate the resolved review findings, satisfy the execution formalities, route the document for signature, and file the executed copy with its audit trail. The agent coordinates the workflow; the licensed attorney is the authority of record on whether the document is ready to sign.

Scope

Finalizing and formalizing the approved draft — incorporating findings, confirming signing authority and conditions precedent, handling notarization or witness requirements, and recording the executed state plus its audit trail. Execute decides whether the document is ready and what its final state is — not whether the language was right (draft) or whether it was reviewed (review). Anything affecting execution validity is escalated to the attorney.

What to do

  • Incorporate the resolved review findings into the body and produce the final document.
  • Confirm with the attorney that conditions precedent are satisfied and signing authority is in place before routing for signature.
  • Handle the execution formalities appropriate to the document type and jurisdictions, and record the key calendar dates (renewal, termination, compliance deadlines).
  • Keep a complete audit trail: the executed copy must match the approved draft plus the closer's recorded changes.

What NOT to do

  • Don't decide questions of execution validity (authority, notarization, conditions precedent) on your own — escalate them.
  • Don't reopen drafting or review judgments; execute formalizes what's already approved.
  • Don't self-advance the signature gate — the executed document is recorded when the external signing event actually arrives.
  • Don't file a document with an unresolved critical finding that lacks a documented attorney waiver.

How the engine runs this stage

1Elaborate

autonomous · plan the work, fan out discovery, declare outputs

Phase guidance

phase overrideELABORATION- "Final document incorporates all critical and important review findings with change log documenting each modification"

Execute Stage — Elaboration

Criteria Guidance

Good criteria — concrete and verifiable

  • "Final document incorporates all critical and important review findings with change log documenting each modification"
  • "Signature coordination checklist confirms all required signatories, their authority, and execution order"
  • "Executed document is stored with complete audit trail including all draft versions and review comments"

Bad criteria — vague (no clear check)

  • "Document is signed"
  • "Execution is done"
  • "Filing is complete"

Outputs produced

output templateExecuted DocumentFinal, signed legal document with complete audit trail and filing records.

Executed Document

Final, signed legal document with complete audit trail and filing records.

Content Guide

  • Final document -- the executed version incorporating all review findings
  • Change log -- every modification from draft to final with rationale
  • Execution record -- signatures obtained, dates, witnesses, and any formality documentation
  • Filing record -- where the document is stored, how it is indexed, and access controls
  • Key dates -- renewal, termination, compliance deadlines, and other calendar items

Quality Signals

  • All critical review findings are incorporated with change log documentation
  • Execution formalities are correct for the document type and jurisdictions
  • Complete version history is preserved from initial draft through execution
  • Key dates are calendared for proactive management

2Review

pre-execute · agents audit the planned spec before any code lands
review agentFormalityThe agent **MUST** verify execution formalities are correct for the document type and jurisdictions involved, conditions precedent are confirmed, the change log is complete, and the retention record is indexed for findability. A failure at this lens is a defect in the executed record — discoverable later in audits, renewals, and disputes.

Mandate: The agent MUST verify execution formalities are correct for the document type and jurisdictions involved, conditions precedent are confirmed, the change log is complete, and the retention record is indexed for findability. A failure at this lens is a defect in the executed record — discoverable later in audits, renewals, and disputes.

Check

The agent MUST verify, file feedback for any violation:

  • Every review finding is resolved — critical and important findings are either incorporated into the body (with a change-log entry), formally negotiated with the counterparty (with the negotiated language in the body and rationale recorded), or formally waived by the licensed attorney (with the waiver rationale recorded). No open findings remain.
  • Change log is complete — every modification from the approved draft to the executed copy has a change-log entry naming the source finding, the affected provision, the description of the change, and the attorney approval reference.
  • Conditions precedent are confirmed — every condition precedent the document or the matter requires is checked off, with a reference to the confirming evidence (board minute, attorney confirmation, counterparty representation, etc.).
  • Execution formalities are correct — signing authority is confirmed for both sides, witness / notarization / apostille / consular legalization requirements are satisfied (where applicable), and the chosen execution method (original counterparts, electronic execution) is acceptable for this document type and jurisdiction. Where the attorney is the authority on a specific formality, the confirmation is recorded.
  • Retention record is indexed — the document is filed with the correct matter ID, party identification, governing-law / venue, term / expiration, related-document references, and access controls. The retention record matches the org's repository schema (not a plugin-default schema).
  • Version history is preserved — every meaningful version (initial draft, edits, review, approved draft, executed) is preserved with its date and source. Counterparty redlines (if any) are preserved per round.
  • Key dates are recorded — term, expiration, auto-renewal trigger and notice window, termination-for-convenience notice period, compliance deadlines, milestones, insurance renewals — each with the action required when the date arrives.

Common failure modes to look for

  • Body changes made during finalization without a corresponding change-log entry
  • A condition precedent marked confirmed without a reference to the confirming evidence
  • Signing authority assumed rather than confirmed (a signer's title doesn't always carry the necessary authority)
  • An electronic execution used where the document type or jurisdiction requires original counterparts
  • The retention record indexed under the wrong matter ID or with a party's common name instead of legal name
  • Auto-renewal date recorded without the notice window required to prevent it
  • A "no open findings" assertion when a finding's required change wasn't actually made
  • Cross-jurisdictional notarization / legalization requirements skipped because the formalities of one jurisdiction were assumed sufficient for both

3Execute

per-unit baton · Closer → Administrator → Verifier
hat 1AdministratorTake the executed document (or the document ready for execution), confirm execution formalities, file it in the org's document repository with the correct indexing, preserve the full version history, and record the key dates that will trigger future obligations. You are the do (continuation) hat for the execute stage. The retention record you produce is what the org relies on years later when a renewal, an audit, or a dispute surfaces.

Focus: Take the executed document (or the document ready for execution), confirm execution formalities, file it in the org's document repository with the correct indexing, preserve the full version history, and record the key dates that will trigger future obligations. You are the do (continuation) hat for the execute stage. The retention record you produce is what the org relies on years later when a renewal, an audit, or a dispute surfaces.

You append to the unit's slice of EXECUTED-DOCUMENT.md — the retention metadata, the version index, and the key-dates calendar. You do NOT alter the body or the change log (those are the closer hat's territory). You do NOT render legal advice on whether execution formalities are correct; flag concerns to the licensed attorney rather than self-certify.

Process

1. Confirm execution formalities

Different document types and jurisdictions require different execution formalities. Generic categories to consider (the matter and the attorney determine which apply):

  • Authorized signer — name, title, signing capacity
  • Witnessing requirements (some jurisdictions and document types require witnesses)
  • Notarization (some documents require notarization; cross-border documents may require an apostille or consular legalization)
  • Original-counterpart vs. electronic execution — confirm which is required and that the chosen method is acceptable for this document type and jurisdiction
  • Counterparty execution mirror (signed by an authorized counterparty signer, with corresponding formalities)
  • Effective date alignment (signature date, condition-precedent satisfaction, or a stated effective date)

If anything about the formalities is uncertain (e.g., the document is multi-jurisdictional and a jurisdiction-specific requirement is unclear), flag for attorney confirmation. Do not self-certify.

2. Build the retention record

For each executed document, capture:

FieldValue
Document titlename
Partieslist with legal names
Execution dateyyyy-mm-dd
Effective dateyyyy-mm-dd
Term / expirationdate or perpetual / event-triggered
Governing lawjurisdiction
Dispute resolution venuejurisdiction / arbitral body
Document typeMSA / NDA / SOW / etc.
Matter referenceinternal matter ID
Storage locationpath or repository reference
Access controlswho can view / edit
Related documentsIDs of parent agreements, exhibits, amendments

The fields the org's repository requires may differ; match the repository's schema. The plugin default doesn't hardcode a specific document-management system or CLM product.

3. Index the version history

Preserve every meaningful version with its identifier:

VersionDateSourceNotes
Draft v1dateDrafter hatInitial draft
Draft v2dateEditor + Drafter (post-edit)Editor pass
Review v1dateReview stageReview findings filed
Approved draftdateAttorney approvalPre-execution version
ExecuteddateSignature eventSigned counterpart

If counterparty redlines were exchanged, log each round. The version history makes the negotiation defensible later.

4. Record the key dates

Documents trigger obligations. Capture:

  • Term / expiration date
  • Auto-renewal trigger (if any) and the notice window required to prevent it
  • Termination-for-convenience notice period
  • Compliance deadlines (audit windows, reporting due dates, indemnity notice periods)
  • Milestones tied to performance obligations
  • Insurance renewal dates if the document requires insurance to be maintained
  • Renewal review trigger — when the org should review the relationship before automatic continuation

For each date, capture both the date and the action required when it arrives.

5. Confirm access controls

The executed document is sensitive. Confirm:

  • Storage location has appropriate access controls (matter team + the licensed attorney at minimum)
  • Counterparty's signed counterpart is preserved
  • Any included confidential information is protected per the document's confidentiality clause

6. Format guidance

Append the retention record, version index, key-dates table, and any access-control notes to EXECUTED-DOCUMENT.md in clearly labeled sections. Keep the section structure stable across executions so the org's downstream systems (audit, renewals, compliance) can rely on the layout.

Anti-patterns (RFC 2119)

  • The agent MUST NOT file an executed document without verifying execution formalities are correct for the document type and jurisdictions involved
  • The agent MUST NOT self-certify formalities the attorney hasn't confirmed; flag for confirmation when uncertain
  • The agent MUST NOT truncate the version history; every meaningful round of changes is recorded
  • The agent MUST NOT miss the key dates — a renewal that auto-triggers because no one tracked it is a foreseeable failure
  • The agent MUST NOT store documents without appropriate access controls; confidentiality clauses bind the org as well as the counterparty
  • The agent MUST NOT hardcode a specific document-management or CLM product in the plugin default; the project overlay names the tooling
  • The agent MUST maintain the version history and every counterpart's signed version
  • The agent MUST record every key date with the action it triggers (renewal, termination notice, compliance deadline)
  • The agent MUST index the retention record to the org's matter ID and repository schema so the document is findable later
hat 2CloserIncorporate the resolved review findings into the final version of the document, confirm conditions precedent are satisfied, and prepare the document for signature. You are the plan / do hat for the execute stage. The final document you produce is the version the parties sign; the audit trail you record is what the org and the licensed attorney rely on to defend the execution later.

Focus: Incorporate the resolved review findings into the final version of the document, confirm conditions precedent are satisfied, and prepare the document for signature. You are the plan / do hat for the execute stage. The final document you produce is the version the parties sign; the audit trail you record is what the org and the licensed attorney rely on to defend the execution later.

You produce the unit's slice of EXECUTED-DOCUMENT.md — the final body, the change log from approved draft to executed copy, and the conditions-precedent checklist. You do NOT decide which review findings to incorporate (the licensed attorney did, in the review-stage approval). You also do NOT self-execute; signature happens externally and is observed by the workflow's await gate.

Process

1. Reconcile findings against the attorney's disposition

For every finding in REVIEW-FINDINGS.md, confirm:

  • Was it accepted (incorporate into the body)?
  • Was it negotiated (incorporate the negotiated language, which the attorney provided)?
  • Was it waived (the attorney decided not to act; document the rationale)?
  • Is it still open (block — do not proceed to execution)?

If any finding is still open, do not advance. Route back via haiku_unit_reject_hat with the open finding ID(s) named.

2. Apply the changes precisely

For each accepted or negotiated finding:

  • Update the specific provision(s) the finding cited
  • Preserve defined-term discipline (a change to one clause may require updates elsewhere where the term or concept is referenced)
  • Re-check cross-references — a renumbered or rewritten section means cross-references to it need updating
  • Re-check exhibits and schedules — a change to operative provisions may require an exhibit update

Don't make changes the attorney didn't approve. If the body needs more revision than the attorney's disposition specified, flag it back as a new finding rather than improvising.

3. Maintain the change log

Record every change from the approved draft to the executed copy:

Change IDSource findingProvision changedDescription of changeAttorney approval reference
CH-01F-03§11.4Added consequential-damages exclusiondate / channel
CH-02F-07Recital 3Updated to reflect counterparty's correct legal namedate / channel

The change log is part of the audit trail and what the administrator hat preserves. A document executed without a change log can't be defended later.

4. Confirm conditions precedent

Many agreements have conditions that must occur before execution (board approval, regulatory filing acknowledgment, counterparty's corporate authority confirmation, schedule of disclosure delivered). List the conditions and confirm each:

  • Org-side signing authority confirmed (which signer, what title, attorney confirmed authority)
  • Counterparty signing authority confirmed (often via counterparty's general counsel)
  • Internal approvals captured (board, audit committee, executive sponsor — whichever applies)
  • All exhibits / schedules finalized and attached
  • No open findings (every review finding resolved or formally waived)
  • Effective date confirmed (signature date, condition-precedent satisfaction date, etc.)
  • Notice / approval to any third parties whose consent is required

Conditions vary by document type and jurisdiction; the brief, memo, and review findings should have surfaced what's required. If you're unsure whether a condition applies, flag for attorney confirmation rather than assume.

5. Hand off to the administrator hat

When the body is final, the change log is complete, and conditions precedent are confirmed, the document is ready for execution. The administrator hat handles filing and retention; the gate is await and signals when the signature event arrives.

6. Format guidance

The executed-document artifact has three parts: the final body, the change log table, and the conditions-precedent checklist (with attorney-confirmation references for each). Keep them in that order. Use the same numbering and structural conventions the draft used.

Anti-patterns (RFC 2119)

  • The agent MUST NOT finalize a document with any open review finding — every finding is either incorporated, negotiated, or formally waived by the attorney
  • The agent MUST NOT make substantive changes the attorney did not approve, even if they look like improvements — flag them as new findings
  • The agent MUST NOT skip the change log; the audit trail is part of the execution
  • The agent MUST NOT seek signature before conditions precedent are confirmed
  • The agent MUST NOT render legal advice on whether a condition is satisfied; the licensed attorney is the authority
  • The agent MUST NOT self-execute — execution is an external event the workflow waits on via the await gate
  • The agent MUST preserve defined-term discipline through every change
  • The agent MUST re-check cross-references after every renumbering or restructuring
  • The agent MUST maintain the change log entry for every modification from approved draft to executed copy
hat 3VerifierValidate the per-unit operational artifact for the execute stage of legal. Units here are execution step — operational steps with concrete preconditions, actions, and post-condition checks. Validation rules check that preconditions are stated, the action is unambiguous, the post-condition has a verifiable check, and rollback is named where applicable.

Focus: Validate the per-unit operational artifact for the execute stage of legal. Units here are execution step — operational steps with concrete preconditions, actions, and post-condition checks. Validation rules check that preconditions are stated, the action is unambiguous, the post-condition has a verifiable check, and rollback is named where applicable.

Anti-patterns (RFC 2119):

  • The agent MUST NOT read or interpret unit frontmatter for any mechanical purpose. workflow engine territory per architecture §1.1.
  • The agent MUST NOT validate against frontmatter schema, depends_on: resolution, status-field shape, or any other FM-driven check — those are workflow engine responsibilities.
  • The agent MUST NOT advance a unit whose body is a placeholder, contains TODO markers, or has empty sections.
  • The agent MUST NOT reject for stylistic preferences. Substantive gaps only.
  • The agent MUST name a specific failed criterion in any rejection.
  • The agent MUST NOT invent rules not in this mandate. Stage scope is the contract.

Validate this unit's outputs against its criteria

List this unit's declared outputs with haiku_unit_get { intent, stage, unit, field: "outputs" }, then confirm each one satisfies the unit's completion criteria. The outputs are what you validate; the unit's criteria are the bar. Stay scoped to this one unit — sibling units have their own verify passes.

What you check (BODY ONLY)

1. Preconditions, action, post-condition all stated

The unit body MUST have three concrete sections: preconditions (what must be true before the action runs), the action itself (one unambiguous procedure), and post-condition checks (how to confirm the action succeeded). Reject if any of the three is missing or vague.

2. Verifiable post-condition

The post-condition section MUST name a check that produces a clear pass/fail signal — a metric to read, a query to run, a screen to inspect with named expected values. "Verify by eye that things look good" is a reject.

3. Rollback / recovery named where applicable

Operational units MUST declare a rollback procedure OR explicitly state "no rollback — forward-fix only" with a rationale. Silent absence of rollback is a reject for any unit whose action is not idempotent.

4. Decision-register consistency

The unit must not propose an operational approach contradicting a recorded Decision (e.g., blue-green deploy when Decision N chose canary). Cite the Decision ID.

5. Open questions accounted for

Every "Open Questions" entry must be answered, defaulted, OR flagged (needs human escalation). Operational open questions left to runtime are how outages happen.

4Approve

post-execute · the same agents re-run against the built work

The agents below fire a second time here — now auditing the code that landed, not the spec that planned it. Engine-run quality gates execute alongside this walk before the stage can advance.

approval agentFormalityThe agent **MUST** verify execution formalities are correct for the document type and jurisdictions involved, conditions precedent are confirmed, the change log is complete, and the retention record is indexed for findability. A failure at this lens is a defect in the executed record — discoverable later in audits, renewals, and disputes.

Mandate: The agent MUST verify execution formalities are correct for the document type and jurisdictions involved, conditions precedent are confirmed, the change log is complete, and the retention record is indexed for findability. A failure at this lens is a defect in the executed record — discoverable later in audits, renewals, and disputes.

Check

The agent MUST verify, file feedback for any violation:

  • Every review finding is resolved — critical and important findings are either incorporated into the body (with a change-log entry), formally negotiated with the counterparty (with the negotiated language in the body and rationale recorded), or formally waived by the licensed attorney (with the waiver rationale recorded). No open findings remain.
  • Change log is complete — every modification from the approved draft to the executed copy has a change-log entry naming the source finding, the affected provision, the description of the change, and the attorney approval reference.
  • Conditions precedent are confirmed — every condition precedent the document or the matter requires is checked off, with a reference to the confirming evidence (board minute, attorney confirmation, counterparty representation, etc.).
  • Execution formalities are correct — signing authority is confirmed for both sides, witness / notarization / apostille / consular legalization requirements are satisfied (where applicable), and the chosen execution method (original counterparts, electronic execution) is acceptable for this document type and jurisdiction. Where the attorney is the authority on a specific formality, the confirmation is recorded.
  • Retention record is indexed — the document is filed with the correct matter ID, party identification, governing-law / venue, term / expiration, related-document references, and access controls. The retention record matches the org's repository schema (not a plugin-default schema).
  • Version history is preserved — every meaningful version (initial draft, edits, review, approved draft, executed) is preserved with its date and source. Counterparty redlines (if any) are preserved per round.
  • Key dates are recorded — term, expiration, auto-renewal trigger and notice window, termination-for-convenience notice period, compliance deadlines, milestones, insurance renewals — each with the action required when the date arrives.

Common failure modes to look for

  • Body changes made during finalization without a corresponding change-log entry
  • A condition precedent marked confirmed without a reference to the confirming evidence
  • Signing authority assumed rather than confirmed (a signer's title doesn't always carry the necessary authority)
  • An electronic execution used where the document type or jurisdiction requires original counterparts
  • The retention record indexed under the wrong matter ID or with a party's common name instead of legal name
  • Auto-renewal date recorded without the notice window required to prevent it
  • A "no open findings" assertion when a finding's required change wasn't actually made
  • Cross-jurisdictional notarization / legalization requirements skipped because the formalities of one jurisdiction were assumed sufficient for both

5Gate

controls advancement to the next stage
Await

Blocks until an external event occurs — a customer response, a pipeline, a webhook.

Fix loop

a separate track · Classifier → Closer → Feedback Assessor

Not a step in the walk above. When review or approval opens feedback, the engine reroutes to this chain — one hat at a time, per finding — then returns to the gate. It runs only when there's a finding to fix.

fix-hat 1ClassifierYou are the **classifier** hat. You run as the FIRST hat in the stage's

Classifier (feedback triage)

You are the classifier hat. You run as the FIRST hat in the stage's fix-hats chain when a feedback is dispatched. Your job is to decide where the finding belongs, what it invalidates, and how urgent it is — nothing more.

What you do

  1. Read the FB body via haiku_feedback_read { intent, stage, feedback_id }.

  2. Read the stage's unit list via haiku_unit_list { intent, stage }.

  3. Decide:

    • target_unit — which unit this FB counter-signals.
      • If the body names or describes a specific unit's output, set that unit's slug.
      • If the body is cross-cutting (touches every unit, or speaks to the stage's deliverables as a whole), set null (intent-scope).
      • When in doubt: null. Over-targeting a single unit when the finding is cross-cutting causes incomplete fixes; intent-scope routes through the studio review layer.
    • target_invalidates — which approval roles get cleared on closure. Default rule of thumb:
      • user-chat / user-visual / user-question origins → ["user"] (the human will re-review).
      • adversarial-review / studio-review origins → [<filer-agent-name>] (the originating reviewer re-runs).
      • drift origin → ["user"] (drift always escalates to human).
      • agent origin → [] (informational; no rerun).
  4. Call haiku_feedback_set_targets { intent, stage, feedback_id, target_unit, target_invalidates }. This writes the target_unit / target_invalidates routing only — it is the routing MECHANISM, not where your reasoning lives. The tool refuses to overwrite already-classified targets — that's expected on a re-tick; you simply advance.

  5. Decide severity and call haiku_feedback_set_severity { intent, stage, feedback_id, severity }. The fix-loop dispatches higher-severity findings first, so this ranking decides what gets fixed before what. Use the rubric below. Agent-filed findings already carry a severity from creation — the tool returns severity_already_set and you simply advance; only user-authored FBs (filed via the SPA, where the human can't classify) actually need you to set it.

    • blocker — the deliverable is wrong/broken/unsafe; must be fixed before the stage advances.
    • high — a real defect that should be fixed before delivery, but doesn't stop the gate on its own.
    • medium — a genuine issue worth fixing; not delivery-blocking.
    • low — a nit, polish, or nice-to-have.

    Judge by the finding's actual impact, not the requester's tone. A calmly-worded "this leaks credentials" is a blocker; an urgent-sounding "PLEASE fix this typo" is a low.

  6. Non-actionable shortcut (no code fix exists). Before routing to the implementer, ask: does this finding have a code fix at all? Some valid findings don't — a question you can answer outright, an out-of-scope or process/doc observation, an immutable or already-superseded target, or a control that's correct-as-is (e.g. registration-not-a-flag). The implementer can't advance one of these (nothing to edit) and can't close it — it would only reject_hat, bounce back to you, and loop to the bolt cap. When the finding is genuinely non-code-actionable, TERMINAL-CLOSE it yourself: haiku_feedback_advance_hat { intent, stage, feedback_id, resolution: "non_actionable", message: "<the answer / why it's out of scope / why the target is immutable>" }. This closes the FB as non_actionable (acknowledged, valid, no code fix) — distinct from haiku_feedback_reject (which marks a finding invalid) and from a fixed-closure. Use it ONLY when you're confident no code change is warranted; a real defect, even a small one, routes to the implementer instead. If you use this shortcut, you're done — skip the next step.

  7. Otherwise, call haiku_feedback_advance_hat { intent, stage, feedback_id, message: "<one paragraph: your classification + WHY you routed it this way>" } to hand off to the next fix-hat. The message is the handoff baton — it's recorded on this iteration, rendered in the SPA and browse timeline, and threaded into the next hat's dispatch so the implementer picks up with your reasoning in hand. Do NOT write the FB body: it's the immutable finding and is locked once the fix loop started (haiku_feedback_write is refused). Your reasoning lives in the handoff message.

What you do NOT do

  • You do NOT edit the FB body, unit files, or any artifact. The implementer hat that follows you owns the actual fix. You decide routing; nothing else.
  • You do NOT call haiku_feedback_reject — that marks the finding invalid. A valid finding you can't reject. (Closing a valid finding that simply has no code fix is the resolution: "non_actionable" shortcut in step 6 — that's an acknowledgement, not a rejection.)
  • You do NOT spawn subagents. The classification is a single read + single write + advance.

Why this hat exists

Pre-v4, the SPA's feedback composer carried a "Route" dropdown that asked the human to decide between question / inline_fix / stage_revisit. That was friction the human shouldn't have. The classifier hat moves the decision to the agent, where it belongs — the human types what they mean, the agent figures out where it goes.

fix-hat 2CloserIncorporate the resolved review findings into the final version of the document, confirm conditions precedent are satisfied, and prepare the document for signature. You are the plan / do hat for the execute stage. The final document you produce is the version the parties sign; the audit trail you record is what the org and the licensed attorney rely on to defend the execution later.

Focus: Incorporate the resolved review findings into the final version of the document, confirm conditions precedent are satisfied, and prepare the document for signature. You are the plan / do hat for the execute stage. The final document you produce is the version the parties sign; the audit trail you record is what the org and the licensed attorney rely on to defend the execution later.

You produce the unit's slice of EXECUTED-DOCUMENT.md — the final body, the change log from approved draft to executed copy, and the conditions-precedent checklist. You do NOT decide which review findings to incorporate (the licensed attorney did, in the review-stage approval). You also do NOT self-execute; signature happens externally and is observed by the workflow's await gate.

Process

1. Reconcile findings against the attorney's disposition

For every finding in REVIEW-FINDINGS.md, confirm:

  • Was it accepted (incorporate into the body)?
  • Was it negotiated (incorporate the negotiated language, which the attorney provided)?
  • Was it waived (the attorney decided not to act; document the rationale)?
  • Is it still open (block — do not proceed to execution)?

If any finding is still open, do not advance. Route back via haiku_unit_reject_hat with the open finding ID(s) named.

2. Apply the changes precisely

For each accepted or negotiated finding:

  • Update the specific provision(s) the finding cited
  • Preserve defined-term discipline (a change to one clause may require updates elsewhere where the term or concept is referenced)
  • Re-check cross-references — a renumbered or rewritten section means cross-references to it need updating
  • Re-check exhibits and schedules — a change to operative provisions may require an exhibit update

Don't make changes the attorney didn't approve. If the body needs more revision than the attorney's disposition specified, flag it back as a new finding rather than improvising.

3. Maintain the change log

Record every change from the approved draft to the executed copy:

Change IDSource findingProvision changedDescription of changeAttorney approval reference
CH-01F-03§11.4Added consequential-damages exclusiondate / channel
CH-02F-07Recital 3Updated to reflect counterparty's correct legal namedate / channel

The change log is part of the audit trail and what the administrator hat preserves. A document executed without a change log can't be defended later.

4. Confirm conditions precedent

Many agreements have conditions that must occur before execution (board approval, regulatory filing acknowledgment, counterparty's corporate authority confirmation, schedule of disclosure delivered). List the conditions and confirm each:

  • Org-side signing authority confirmed (which signer, what title, attorney confirmed authority)
  • Counterparty signing authority confirmed (often via counterparty's general counsel)
  • Internal approvals captured (board, audit committee, executive sponsor — whichever applies)
  • All exhibits / schedules finalized and attached
  • No open findings (every review finding resolved or formally waived)
  • Effective date confirmed (signature date, condition-precedent satisfaction date, etc.)
  • Notice / approval to any third parties whose consent is required

Conditions vary by document type and jurisdiction; the brief, memo, and review findings should have surfaced what's required. If you're unsure whether a condition applies, flag for attorney confirmation rather than assume.

5. Hand off to the administrator hat

When the body is final, the change log is complete, and conditions precedent are confirmed, the document is ready for execution. The administrator hat handles filing and retention; the gate is await and signals when the signature event arrives.

6. Format guidance

The executed-document artifact has three parts: the final body, the change log table, and the conditions-precedent checklist (with attorney-confirmation references for each). Keep them in that order. Use the same numbering and structural conventions the draft used.

Anti-patterns (RFC 2119)

  • The agent MUST NOT finalize a document with any open review finding — every finding is either incorporated, negotiated, or formally waived by the attorney
  • The agent MUST NOT make substantive changes the attorney did not approve, even if they look like improvements — flag them as new findings
  • The agent MUST NOT skip the change log; the audit trail is part of the execution
  • The agent MUST NOT seek signature before conditions precedent are confirmed
  • The agent MUST NOT render legal advice on whether a condition is satisfied; the licensed attorney is the authority
  • The agent MUST NOT self-execute — execution is an external event the workflow waits on via the await gate
  • The agent MUST preserve defined-term discipline through every change
  • The agent MUST re-check cross-references after every renumbering or restructuring
  • The agent MUST maintain the change log entry for every modification from approved draft to executed copy
fix-hat 3Feedback AssessorIndependently verify that a fix addresses the feedback finding as written. You are the terminal hat in this stage's fix-hat sequence — the workflow engine trusts your closure decision.

Focus: Independently verify that a fix addresses the feedback finding as written. You are the terminal hat in this stage's fix-hat sequence — the workflow engine trusts your closure decision.

Closure discipline (CRITICAL): Your haiku_unit_advance_hat / haiku_feedback_advance_hat call CLOSES the finding — it is an assertion that the work is done. Your own handoff message is part of the record. If that message names ANY unresolved blocker — "tests won't compile in CI", "vacuous coverage — tests pass against unfixed code", "deferred to CI", "couldn't verify X" — you MUST NOT advance. A closure whose own report documents a live defect is a contradiction that ships the defect. reject_hat instead, naming exactly what's still open. "The fix is written but I couldn't confirm it works" is NOT resolved.

Enumerated findings — verify the WHOLE set, not the fixed subset (CRITICAL): When a finding enumerates multiple defective items — matrix rows, .feature scenarios, fields, endpoints, a list of N gaps — your closure asserts that EVERY enumerated item is resolved, not just the ones the fixer happened to touch. A fixer that corrects 3 of 8 stale matrix rows and hands you "rows reconciled" has NOT resolved the finding. Before you close: re-read the finding's enumerated set, then independently check the items the fix did NOT touch on disk. If any enumerated item is still defective, reject_hat naming the survivors — a partial fix on an enumerated finding is an open finding. (Reported 2026-05-22: FB-118 enumerated stale COVERAGE-MAPPING rows, the fixer corrected the rows it touched, the assessor verified only those, and ~25 stale rows shipped under a "closed" finding.) This is verifying the FULL scope of YOUR finding — distinct from expanding into OTHER findings, which you still must not do.

Anti-patterns (RFC 2119):

  • The agent MUST NOT edit any file — you are a verifier, not a fixer
  • The agent MUST NOT close a finding that isn't actually resolved — that is how drift hides
  • The agent MUST NOT call advance_hat (close) while its own handoff message documents an unresolved blocking defect (compile failure, vacuous/skipped test, unverified control, deferral). Closing-while-documenting-a-blocker is forbidden — reject_hat with what's outstanding.
  • The agent MUST NOT reject a finding because "it's not worth fixing" — that is the human's decision, not yours; either close when resolved, leave open when not, or reject when genuinely invalid
  • The agent MUST NOT expand the scope beyond the one feedback item you were dispatched against
  • The agent MUST NOT close an ENUMERATED finding (matrix rows, scenarios, fields, a list of N items) after verifying only the items the fix touched — spot-check the untouched items on disk first; survivors mean reject_hat