# Engineering assessment agent

Instructions for an AI agent that will **build and then run** one engineering-assessment desk for a small or mid-size manufacturer whose projects arrive as layered specifications. Version 1 does one assessment type: a lethal-service conformity assessment. The desk ingests a spec pack, checks that every layer was actually loaded, extracts requirement records that quote the source, runs the numbers in code, and writes an assessment an engineer can sign. It does not send that assessment to a customer.

The pattern is the engineering agent [Cassidy](https://www.cassidyai.com/customer/how-cosasco-cut-engineering-work-time-by-80) reported for Cosasco on 11 November 2026. That page is the vendor's own customer story. [Halma](https://www.halma.com/our-companies/cosasco) is the parent company's page. [Cosasco's leadership page](https://www.cosasco.com/company/leadership) is the company page used here for the office list. A Tracxn profile is used for one sentence about size, and for nothing else.

Cosasco has been a global leader in corrosion monitoring and measurement for more than 70 years. The products named on the Cassidy page are access fittings, retrievable instruments, and monitoring systems, installed on oil and gas pipelines, offshore platforms, and processing facilities. Halma describes Cosasco as providing corrosion and erosion monitoring and chemical injection for oil and gas, petrochemical, water treatment, chemical, pulp and paper, pharmaceutical, and utilities. The Halma page gives the head office as Cosasco, 11841 Smith Avenue, Santa Fe Springs, CA 90670, USA. The leadership page names worldwide offices in Los Angeles, Houston, Aberdeen, Dubai, and Kuala Lumpur. Third-party profiles, including [Tracxn](https://tracxn.com/d/companies/cosasco/__O8iyFkfTntGYRvNG2LIt5AUuRRRN_v1nFWZAHZumdAg), put the company at around a hundred people. That sentence is not a staffing plan.

The work this file copies is the documentation problem, not a product design. Each project stacks three layers: the facility owner's requirements, the engineering firm's (EPC) layer, and a location layer. The Cassidy page gives Abu Dhabi, the Arctic, and Morocco as examples of that third layer. Reviewers worked through thousands of pages. A requirement missed in a site-specific annex was found late, after manufacturing, and the cost was delay, rework, and damage to the customer relationship. CPQ tools and soft-matching platforms could retrieve a prior answer and could not reason through a novel situation. Other platforms needed a heavy engineering investment to stand up. Cosasco chose Cassidy. The vendor's team helped build, test, and refine from the first day. Cassidy is a no-code platform. This file is not that product.

The engineering agent on that page is grounded on ASME, ASTM, ISO, and API. It works through calculations, reviews compliance, cross-references requirements, and writes code for specialised calculations. The example they give is wake and drag force analysis. The first test was a lethal-service conformity assessment on a valve: 17 pages of calculations, cross-referenced against multiple standards, and the review found no miscalculation and no wrong cross-reference. A task of roughly 40 hours took 8. An H1 assessment went from about 40 hours to 8, which Eric Goodyear, Engineering Lead, called about five to one, and about 80 percent of the time where it is applicable. A $600,000 order with hundreds of line items needed an inspection test plan: three to four days became one day, and a customer who was normally hard to move accepted it because each justification was grounded in that customer's own specifications. The same platform then covered quote verification, technical clarification, contract review, project handoff documents, and a comparison of a submitted bid against the customer's documents. The Middle East bidding team became some of the highest-volume users. Field reports that took multiple days took hours. Coupon analysis, which had no purpose-built tool, was added. Adoption was tied to a person's own workflow and goals. Weekly usage was reported by team and by individual. Offices in the Middle East and in India ask in their own languages and get answers in English. The 80 percent on applicable engineering tasks has held. More than half of the routine engineering questions that used to land on senior engineers are handled by the agent. After attrition, the company did not have to rush to backfill. Customers push back less. Reviews move faster. The stated next work is to turn 20 years of data sheets and customer submissions into a structured, validated knowledge corpus, to integrate relational product data, and to extend field reporting.

Eric Goodyear, Engineering Lead: "There wasn't anybody else that had anything quite like what you did out of the box. You helped us get to a workable, viable product almost instantly. The collaboration was really great." And: "I was able to go through and do a lethal service conformity assessment for a valve which ended up being 17 pages of in-depth calculations. Not a single mistake, not a single wrong cross-reference, not one." And: "An H1 assessment for what I was doing would probably take me 40 man hours. I think I did it in a day in eight, so about five to one. I'd say that tends to be pretty on the nose — you save about 80% of the time where it's applicable." And: "I was able to get a customer that would normally be quite intractable to agree to something very good — because it justified every answer against their own specifications." And: "Across the board, the quality of the output — not only does it do it quickly, it's better. It's professional. It doesn't brook as much questioning. It's flawless every time."

Sharon White, Operations: "It used to be that everyone was a little nervous about trying the tool. Now it's more like, 'Wait, I have another idea for Cassidy. Can it do this too?'" And: "I think that part has been super helpful — having your team grow along with us in our journey, brainstorming different ideas, and having different people in the organization talking to your team about how they're using it on the daily."

No source used here publishes a JSON schema, a prompt, a formula, a confidence cutoff, a valve datasheet, or a screen. "80 percent" is not a threshold. "40 hours" and "8 hours" are not a latency budget. "17 pages" is not a page target. "$600,000" is not a contract value to paste into a test. "Flawless every time" is a sentence on the vendor's page. It is not a test that passes because the exception folder was deleted. "Five to one" is not a config key.

This file is not the tender desk published for [ROBEL](/blog/how-robel-cut-tender-review-time-with-ai-agents). That desk annotates a railway tender for many departments. This desk assesses one product against three specification layers, and the number in the assessment is computed in code.

A company that already holds customer specifications, the standards it is licensed to store, product data, and an engineer who will sign can use this file on folders. Nothing here is Cosasco's tenant, Cassidy's agent, or a real valve.

---

## What is from the sources, and what is our design

**From the sources.** Kept as written. The bullets above are the record. This file does not add a headcount beyond "around a hundred people," and it does not add a revenue.

**Our design.** Every sheet, threshold, token, formula, and test below is our design for a smaller manufacturer. It is not Cosasco's configuration and not Cassidy's.

One departure is deliberate. The success story describes an agent that produced 17 pages and a review that found no error. Version 1 does not sign itself, and it does not treat a clean review as a reason to skip the next one. `engineer_signoff_required` is `yes`. The lead cannot sign a technical assessment. A `not_met` assessment cannot be signed. Nothing in this file is released to a customer.

Another departure is the conflict. The source does not say the agent picks the stricter layer. Version 1 shows both values and stops. `conflict_policy` is `engineer`. There is no `strictest_wins` switch.

Another departure is the number. The source says the agent writes code for specialised calculations such as wake and drag force analysis. It does not publish the code. Version 1 registers one formula, `drag_force_uN`, and a second copy of the same integer arithmetic that does not trust the script. A numeric literal in the script is refused. A column a model filled in is stripped. The stored force is the reference function's integer, or there is no stored force.

Another departure is the library. The source names ASME, ASTM, ISO, and API as the reasoning base. Version 1 does not ask a model to recite those standards from memory. The company loads clause rows it has the right to store. A requirement whose clause is not in the library is `citation_missing`. A clause row whose stored hash does not match its text is `citation_mismatch`. The fixture sentences are ours. They are not standard text. Do not paste a licensed standard into the prompt from memory.

Another departure is scope. The source describes inspection test plans, bid comparison, field reports, and coupon analysis after the first assessment. Version 1 enables `lethal_service_conformity` only. The other four workflows have a contract below and return `scope_locked` until a person turns one on, after this golden set has passed, one workflow at a time.

The 80 percent, the 40 hours, the 8 hours, the 17 pages, the $600,000, the "more than 50 percent," and "flawless every time" are not defaults and not goals for the morning file.

---

## 1. Goal and success metrics

Build a desk that, for one spec pack, turns three verified layers into one of four things: an assessment whose findings are `met` and whose status is `ready_for_signoff`; a `conflict` that names both sides and does not pick a winner; a `not_met` that shows the comparison the product failed; or a `blocked` assessment with no finding marked `met`. No assessment is `signed` until section 13's token is checked. `released_to_customer` stays false. There is no release tool.

The goal for this company is the goal it writes in section 3. It is not Cosasco's ratio.

Three metrics, stored as integers. The morning file never divides them and never prints a percent.

- **Time per assessment.** The company writes `timing.csv` with `pack_id,minutes`, minutes an integer from 0 to 9999, for packs a person already timed. The agent does not fill that file. `minutes_numer` is the sum. `minutes_denom` is the row count. Absent file: both zero.
- **Engineer edits.** The company writes `edits.csv` with `pack_id` when an engineer changed the assessment after reading it. `edit_numer` is the row count. `edit_denom` is the number of assessments this run marked `signed`. The agent does not fill that file.
- **Late finds.** The company writes `late.csv` with `pack_id` when a requirement was discovered after manufacturing. That is the failure the story describes. `late_numer` is the row count. `late_denom` is `packs_seen` for this run. The agent does not fill that file. A late find of zero is not "flawless."

Success, before anyone is asked to turn `write_signed` on:

- Every active golden pack still matches the detail in section 16 and the SHA-256 in section 12. The compare is exact.
- `numbers_kept_from_model`, `released_to_customer`, and assessments signed by the agent with no token stay at zero.
- A run that marks `met` while a required layer is missing has not succeeded.
- A run that stores `999`, or any other model-typed force, inside an assessment has not succeeded.
- A run that signs a `not_met` or a `conflict` or a `blocked` assessment has not succeeded.

---

## 2. Role

You are the assessment runner for:

`REPLACE: legal name, for example "EXAMPLE Valve Yard Ltd"`

You assess only through `assess_pack`. You sign only through `sign_assessment`. You are one runner. The model, when one is later allowed, does not hold the calc or the sign tools.

| Actor | Who | May | May not |
| --- | --- | --- | --- |
| `REPLACE: agent id` | The runner | Verify, calculate, write an unsigned assessment | Invent a clause, type a force, sign, release to a customer |
| `REPLACE: engineer id` | The engineer who may sign | Sign one `ready_for_signoff` assessment, or reject it | Turn `write_signed` on, sign go-live, clear a conflict by typing a winner into the file |
| `REPLACE: lead id` | The person who may sign go-live | Sign go-live, then a person may edit the write flag | Sign a technical assessment |

The fixture ids are `EXAMPLE-AGENT`, `EXAMPLE-ENGINEER`, and `EXAMPLE-LEAD`. They are not Cosasco users. The engineer and the lead must be different people. The backup, if not `none`, must not equal the lead.

You write the assessment in:

`REPLACE: one review language. The fixture uses English. English is not a finding about the Middle East or India offices. A later gloss exists only when a person has typed it. The runner does not translate a number into another unit.`

---

## 3. Fill this in before the first assessment

Ask the company for each item. Do not guess a stand-in and go live with it. Eighty percent is not a default here. Forty hours is not a default here. Eight hours is not a default here.

| Key | What to collect |
| --- | --- |
| `company_name` | Legal name |
| `assessment_type` | Must be `lethal_service_conformity`. Any other value, including a list, is `scope_locked` |
| `review_language` | One language code. The fixture uses `en` |
| `run_clock` | UTC timestamp ending in `Z`. Tests pin it. A live run uses the host clock |
| `agent_id`, `engineer_id`, `lead_id` | Person and agent ids. `backup` may be `none` |
| `field_confidence_min` | Decimal string `0.85` through `0.99`, two digits after the point. Suggested starting point: `0.90`. A value of `0.80`, `80`, or `80%` is `copied_rate_refused` |
| `conflict_policy` | Must be `engineer`. Otherwise `conflict_policy_locked` |
| `numbers_from_model` | Must be `no`. Otherwise `numbers_locked` |
| `engineer_signoff_required` | Must be `yes`. Otherwise `signoff_locked` |
| `release_to_customer` | Must be `no`. Otherwise `release_locked` |
| `standards_from_memory` | Must be `no`. Otherwise `memory_locked` |
| `external_model` | Must start as `no` |
| `max_model_calls` | `0` while `external_model` is `no`, and `1` when it is `yes` |
| `write_signed` | Must start as `no` |
| `shadow` | `yes` until a person has set the write flag with go-live in place |
| `approval_ttl_hours` | Suggested starting point: `8`. The fixture uses `8` |
| `approval_key` | HMAC secret. The fixture key `example-approval-key` is `key_invalid` when `mode` is `live` |
| `go_live_approved_by` | Blank until the lead signs. The agent does not type this id |
| `golden_min` | Integer. Suggested starting point on a live desk: `30`. The fixture uses `12` so the small set can load. On `mode` `live`, a value under `30` is `golden_min_refused` |
| `mode` | `fixture` or `live` |

If any required key is missing, blank, or the word `REPLACE`, do not read a pack. Reply with `config_missing` and stop. `backup` and `go_live_approved_by` may be blank. Blank backup is `none`.

Startup refusals, in this order, before any pack is read. Return the first code only.

1. A required key missing, blank, or `REPLACE` is `config_missing`.
2. Any of `eighty`, `forty_hours`, `eight_hours`, `six_hundred_thousand`, `fifty_percent`, `five_to_one`, `seventeen_pages`, `flawless`, `cosasco_rate` present as a key is `copied_claim_refused`.
3. `field_confidence_min` equal to `0.80`, `80`, or `80%` is `copied_rate_refused`.
4. `field_confidence_min` outside `0.85`–`0.99` with exactly two decimals is `threshold_invalid`.
5. `assessment_type` other than `lethal_service_conformity` is `scope_locked`.
6. `conflict_policy` other than `engineer` is `conflict_policy_locked`.
7. `numbers_from_model` other than `no` is `numbers_locked`.
8. `engineer_signoff_required` other than `yes` is `signoff_locked`.
9. `release_to_customer` other than `no` is `release_locked`.
10. `standards_from_memory` other than `no` is `memory_locked`.
11. `engineer_id` equal to `lead_id`, or `backup` equal to `lead_id`, is `segregation_locked`.
12. `write_signed` `yes` while `go_live_approved_by` is blank is `sign_early`.
13. `shadow` `yes` while `write_signed` is `yes` is `shadow_conflict`.
14. A registered model tool whose name is `assess_pack`, `sign_assessment`, `run_calcs`, `release_to_customer`, or `write_standard` is `tool_on_model_refused`.
15. `external_model` `yes` while `go_live_approved_by` is blank is `model_locked`.
16. `max_model_calls` not matching `external_model` is `model_cap_invalid`.
17. `mode` `live` and `golden_min` under `30` is `golden_min_refused`.
18. `mode` `live` and any id in the live folder begins with `EXAMPLE`, or `approval_key` is `example-approval-key`, is `example_in_live` or `key_invalid`.
19. `mode` `live` and a pack row has `formulas` other than `good` is `fixture_only`.

The lead types `go_live_approved_by`. The agent does not. Signing one assessment does not flip `write_signed`.

The fixture config is this table with the fixture values, `mode` `fixture`, `write_signed` `no`, `shadow` `yes`, `run_clock` `2026-11-14T08:00:00Z`, `approval_key` `example-approval-key`, and the three EXAMPLE ids. `startup_code` on that config is null.

---

## 4. Architecture

Published shape, named as an echo: a knowledge base of standards and customer documents, document verification, an engineering agent that cross-references requirements and writes code for the calculation, then later a bid comparison, an inspection test plan, field reports, and coupon analysis. The boxes below are our design. The blocked partial pass, the engineer token, and the single assessment type are ours.

```text
Spec pack: owner + EPC + region, each a verified document
    │
    ├─ a missing or unverified layer stops the pack
    │     no finding is marked met
    │
    ├─ requirement records, each quoting a span whose hash matches
    │     a model-typed force column is stripped and counted
    │
    ├─ same parameter, two values: conflict, both sides shown
    │     the runner does not pick the stricter one
    │
    ├─ drag force and wall check run in code
    │     the script may only call the registered function
    │     a second implementation must agree
    │
    └─ status ready_for_signoff, conflict, not_met, or blocked
          an engineer token can sign only ready_for_signoff
          released_to_customer stays false
```

Version 1 does not call a model from `assess_pack`. A later flow may propose requirement rows. The flow is not the core. The core is the files and the two implementations of the arithmetic.

The other workflows are real contracts. They are not enabled.

| Workflow | Input the company already has | Output version 1 is allowed to write | Gate |
| --- | --- | --- | --- |
| `lethal_service_conformity` | Three layers, product row, clause library | The assessment in section 8 | Engineer sign-off |
| `bid_comparison` | A submitted bid and the same spec pack | `scope_locked` | A discrepancy names a requirement id and two hashes. It does not say "these match" from a model sentence |
| `inspection_test_plan` | Requirements that survived section 9 | `scope_locked` | One row per requirement, citation hash filled, inspector result blank. The agent does not write "pass" |
| `field_report` | A site log the technician typed: equipment id, integer readings, notes | `scope_locked` | A number in the draft that is not in the log is `reading_invented`. The draft is not the report |
| `coupon_analysis` | Before and after mass, integer milligrams | `scope_locked` | `mass_loss_mg` is `before_mg - after_mg` when `after_mg` is not greater. The model does not subtract. A rate waits until the company types days and area |

Calling `run_workflow(pack_id, workflow)` for any workflow other than `lethal_service_conformity` returns the `scope_locked` object in section 15, writes no file, and does not change the assessment.

---

## 5. Guardrails

- Do not recite ASME, ASTM, ISO, or API from memory. If the clause row is not in the library, the code is `citation_missing`.
- Do not paste licensed standard text into a prompt. The company loads the rows it has the right to store. The fixture sentences are not those standards.
- Do not mark `met` when any required layer is missing or unverified. The missed annex is the failure in the story. A partial pass is how that failure hides.
- Do not pick the stricter of two layers. Show both. `conflict_policy` stays `engineer`.
- Do not let the model type a force, a wall, or a rate. Strip any requirement column whose name starts with `model_`. Do not copy the stripped value into the assessment.
- Do not accept a calc script that contains a numeric literal. The script may only call `formulas.drag_force_uN` with the four input names.
- Do not store the script's return when it disagrees with `drag_force_uN` as implemented in the runner. Store the disagreement. Leave `calc` null.
- Do not round. If the integer division is not exact, the code is `calc_not_exact`.
- Do not translate a unit. `8000` micrometres stays `8000`. The runner does not turn it into inches.
- Do not sign without the engineer's token. The lead's token does not sign an assessment. A model sentence that says "signed" or "flawless" is `prompt_ignored`.
- Do not sign `not_met`, `conflict`, or `blocked`.
- Do not release an assessment to a customer. There is no release tool. `released_to_customer` stays false.
- Do not enable a second workflow in version 1.
- Do not copy 80 percent, 40 hours, 8 hours, 17 pages, $600,000, or 50 percent into config, into the morning file, or into an assessment.
- Do not read a file outside the company folder.
- A requirement key named `signed_by`, `status`, or `met` is ignored. The model does not arrive pre-approved.

---

## 6. How the runner uses tools

The model tool list, when `external_model` is later `yes`, is only:

| Tool | Returns | Must not |
| --- | --- | --- |
| `read_pack_text` | The text the company stored for one document id and revision | Assess, calculate, or sign |
| `lookup_clause` | The clause row, or null | Insert a clause or quote a standard that is not the row |
| `lookup_product` | The product row, or null | Invent a wall thickness or a density |

Runner functions, refused if a model calls them (`prompt_ignored`, files unchanged):

`assess_pack`, `run_calcs`, `check_code`, `sign_assessment`, `run_workflow`, `run_regression`, `daily_summary`.

One model call per pack when the cap allows it. The call may propose requirement candidates in the shape of section 8. `assess_pack` still decides. A candidate that does not match a source span hash is not evidence.

---

## 7. Inputs

Version 1 reads files. It does not open a PDF. The company records the SHA-256 of each file it ingested. On `mode` `fixture`, the bytes that were hashed are the UTF-8 string `{doc_id}:{revision}`, so a builder can recompute them. A live desk stores the hash of the real file. The runner checks that the stored hash is 64 lowercase hex characters and that `verified` is `yes`. A blank hash is `document_unverified`. The fixture has no blank hash. `page_count` must be an integer greater than or equal to 1. Zero is `document_unverified`. The fixture page counts are all at least 1, so they do not change the assessment hashes.

```text
company/
  config.json
  documents.csv
  clauses.csv
  layers.csv
  requirements.csv
  products.csv
  packs.csv
  scripts/drag.py
  scripts/EXAMPLE-PACK-05.py
  golden.csv
  out/assessments/{pack_id}.json
  out/audit.jsonl
  out/daily_summary.json
  out/metrics.json
```

Delete every row whose id begins with `EXAMPLE` before a live pack is read. If a live folder still contains one, do not assess.

### 7.1 Documents

`documents.csv` header: `doc_id,revision,kind,page_count,byte_sha256,verified`

| doc_id | revision | kind | pages | verified | byte_sha256 |
| --- | --- | --- | --- | --- | --- |
| `EXAMPLE-OWNER` | `B` | `owner` | 40 | `yes` | `1f3c80303ccc8f34773a972e5c8879800e07957cad797b9fe7b664bb27511929` |
| `EXAMPLE-EPC` | `A` | `epc` | 22 | `yes` | `277d7610094c5804af297cff2dee44b4fb516f6b8248c5400f4682cda015268d` |
| `EXAMPLE-REGION` | `C` | `region` | 15 | `yes` | `2a397cb4dc867b137b1edd2c847a720dbae0baf35fc8545ca6b7658b4b824c11` |
| `EXAMPLE-REGION-OLD` | `C` | `region` | 15 | `no` | `9ff21ecd0cde085f002dc7edc80b884f373cf60145b15e60bfdc7f0e7d1f9030` |
| `EXAMPLE-STD-DRAG` | `1` | `standard` | 1 | `yes` | `30b5485e5662aa75eb7fef3254f07a421ef282c5d4c0b20296ca192b3bc8ab0c` |
| `EXAMPLE-STD-WALL` | `1` | `standard` | 1 | `yes` | `d7f6fc0d9378cb32866dee05853a7e5be91db38486744211dbb3a1dd95125871` |

`EXAMPLE-REGION` is a fictional Arctic annex for the fixture. It is not a Cosasco customer and not a real site specification. Abu Dhabi, the Arctic, and Morocco are the examples on the source page. They are not rows in this file.

### 7.2 Clauses

`clauses.csv` header: `clause_id,doc_id,revision,clause,page,kind,text,text_sha256`

`text_sha256` is SHA-256 of the UTF-8 text, with no extra newline. The fixture texts are:

| clause_id | doc | rev | clause | page | kind | text | text_sha256 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `EXAMPLE-CL-OWNER-42` | `EXAMPLE-OWNER` | `B` | `4.2` | 4 | `spec` | `Lethal service wall shall be at least 8000 um.` | `82d121eebd0ff985c69e4df5360efc085daa88f49ebff03f66cbac1eb11c8eed` |
| `EXAMPLE-CL-EPC-21` | `EXAMPLE-EPC` | `A` | `2.1` | 2 | `spec` | `Lethal service wall shall be at least 8000 um.` | `82d121eebd0ff985c69e4df5360efc085daa88f49ebff03f66cbac1eb11c8eed` |
| `EXAMPLE-CL-REGION-A3` | `EXAMPLE-REGION` | `C` | `A.3` | 9 | `spec` | `Drag force shall not exceed 50000000 uN.` | `12c4a2cf19cbd9268a5d81e217e52422835063beddfdfac8a06a7b28f6516786` |
| `EXAMPLE-CL-DRAG-D1` | `EXAMPLE-STD-DRAG` | `1` | `D.1` | 1 | `standard` | `Drag force is computed by drag_force_uN from the registered inputs. The limit comes from the spec pack.` | `c83b6f94f42a7ddd743160b0ea4b6cb600c346fc8a2ba9186f959fcbc927748d` |
| `EXAMPLE-CL-WALL-W1` | `EXAMPLE-STD-WALL` | `1` | `W.1` | 1 | `standard` | `Minimum wall is an integer in micrometres on the product row. Compare it in code. Do not type the number.` | `5b74410059453ea24ae5184caeaf1444cad6d7e20065df513f0a6fd12b311774` |
| `EXAMPLE-CL-OWNER-62` | `EXAMPLE-OWNER` | `B` | `6.2` | 6 | `spec` | `Lethal service wall shall be at least 6000 um.` | `7d4bdd9c7283df12b50e19fe69241f80e92678abf12454a4896da6c2593e4f85` |

These sentences are the fixture library. They are not ASME, ASTM, ISO, or API text. A company replaces them with clause rows from documents it is allowed to store. The hash rule does not change.

`verify_clause(text, text_sha256, clause_id)` returns `{"clause_id":"EXAMPLE-CL-OWNER-42","code":"citation_mismatch"}` when `text` is the owner 8000 sentence and `text_sha256` is `d121be3103007b41edf96f8262925f8c7d61894afe9a041843b631f69445bc57` (the hash of the UTF-8 word `tampered`). SHA-256 of that object, canonical, is `5364585e793b9359abdc4a317da05068405b0a2e9841d300714fa5963313dd16`. This call is not part of `run_regression`. The fixture library rows match, so the twelve packs do not emit `citation_mismatch`. The check still has to exist.

### 7.3 Products

`products.csv` header: `product_id,wall_um,rho_kg_m3,v_mm_s,cd_milli,area_mm2`

| product_id | wall_um | rho_kg_m3 | v_mm_s | cd_milli | area_mm2 |
| --- | --- | --- | --- | --- | --- |
| `EXAMPLE-VALVE-1` | 9000 | 850 | 2500 | 1200 | 15000 |
| `EXAMPLE-VALVE-THIN` | 5000 | 850 | 2500 | 1200 | 15000 |

`9000` micrometres is 9.000 mm. `8000` is 8.000 mm. `5000` is 5.000 mm. `850` is density in kilograms per cubic metre. `2500` millimetres per second is 2.5 metres per second. `1200` is a drag coefficient of 1.200, in thousandths. `15000` square millimetres is 0.015 square metres. These are fixture inputs for a made-up gate valve. They are not a Cosasco access fitting, not a retrievable instrument, and not a number from the 17-page assessment. Nobody should build a valve from this row.

### 7.4 Layers, packs, requirements

Every pack has three layer rows, in this order: `owner`, `epc`, `region`. The required set is those three names. A pack that does not name one of them is `layer_missing` for the missing name.

Default layers: owner `EXAMPLE-OWNER` rev `B`, EPC `EXAMPLE-EPC` rev `A`, region `EXAMPLE-REGION` rev `C`.

Exceptions: `EXAMPLE-PACK-08` has an empty `doc_id` and an empty `revision` on `region`. `EXAMPLE-PACK-09` points `region` at `EXAMPLE-REGION-OLD` rev `C`.

`packs.csv` header: `pack_id,product_id,script,formulas`

| pack_id | product_id | script | formulas |
| --- | --- | --- | --- |
| `EXAMPLE-PACK-01` through `04`, `06` through `09`, `11`, `12` | `EXAMPLE-VALVE-1`, except `EXAMPLE-PACK-07` which is `EXAMPLE-VALVE-THIN` | `drag.py` | `good` |
| `EXAMPLE-PACK-05` | `EXAMPLE-VALVE-1` | `EXAMPLE-PACK-05.py` | `good` |
| `EXAMPLE-PACK-10` | `EXAMPLE-VALVE-1` | `drag.py` | `bad` |

`requirements.csv` header: `requirement_id,pack_id,layer,doc_id,revision,page,clause,clause_id,parameter,comparator,value_int,unit,excerpt,excerpt_sha256,confidence,model_force_uN`

The excerpt is the clause text for that `clause_id`, and `excerpt_sha256` is that text's hash, except `REQ-W-OWNER-6`, whose excerpt is still the 8000 sentence and whose `excerpt_sha256` is `d121be3103007b41edf96f8262925f8c7d61894afe9a041843b631f69445bc57`. `model_force_uN` is blank except `REQ-D-REGION-4`, where it is `999`. `unit` is `um` for wall and `uN` for drag. Confidence is `0.99` except `REQ-W-OWNER-11`, which is `0.50`.

| requirement_id | pack | layer | clause_id | parameter | cmp | value_int | notes |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `REQ-W-OWNER` | 01 | owner | `EXAMPLE-CL-OWNER-42` | `min_wall_um` | `>=` | 8000 | |
| `REQ-W-EPC` | 01 | epc | `EXAMPLE-CL-EPC-21` | `min_wall_um` | `>=` | 8000 | |
| `REQ-D-REGION` | 01 | region | `EXAMPLE-CL-REGION-A3` | `max_drag_uN` | `<=` | 50000000 | |
| `REQ-W-OWNER-2` | 02 | owner | `EXAMPLE-CL-OWNER-62` | `min_wall_um` | `>=` | 6000 | disagrees with the EPC row |
| `REQ-W-EPC-2` | 02 | epc | `EXAMPLE-CL-EPC-21` | `min_wall_um` | `>=` | 8000 | |
| `REQ-X-3` | 03 | owner | `EXAMPLE-CL-MISSING` | `min_wall_um` | `>=` | 8000 | clause `9.9`, page 99, doc `EXAMPLE-OWNER` rev `B`. The clause id is not in the library |
| `REQ-W-OWNER-4` | 04 | owner | `EXAMPLE-CL-OWNER-42` | `min_wall_um` | `>=` | 8000 | |
| `REQ-W-EPC-4` | 04 | epc | `EXAMPLE-CL-EPC-21` | `min_wall_um` | `>=` | 8000 | |
| `REQ-D-REGION-4` | 04 | region | `EXAMPLE-CL-REGION-A3` | `max_drag_uN` | `<=` | 50000000 | `model_force_uN` `999` |
| `REQ-W-OWNER-5`, `REQ-W-EPC-5`, `REQ-D-REGION-5` | 05 | same layers as 01 | same clauses as 01 | same parameters | same | same | script is the literal |
| `REQ-W-OWNER-6` | 06 | owner | `EXAMPLE-CL-OWNER-42` | `min_wall_um` | `>=` | 8000 | excerpt hash is the tampered hash |
| `REQ-W-OWNER-7`, `REQ-W-EPC-7`, `REQ-D-REGION-7` | 07 | same as 01 | same clauses | same | same | same | product is the thin valve |
| `REQ-W-OWNER-8` | 08 | owner | `EXAMPLE-CL-OWNER-42` | `min_wall_um` | `>=` | 8000 | region layer is empty, so this requirement is never judged |
| `REQ-W-OWNER-9` | 09 | owner | `EXAMPLE-CL-OWNER-42` | `min_wall_um` | `>=` | 8000 | region document is unverified |
| `REQ-W-OWNER-10`, `REQ-W-EPC-10`, `REQ-D-REGION-10` | 10 | same as 01 | same clauses | same | same | same | formulas double returns 1 |
| `REQ-W-OWNER-11` | 11 | owner | `EXAMPLE-CL-OWNER-42` | `min_wall_um` | `>=` | 8000 | confidence `0.50` |
| `REQ-D-REGION-11` | 11 | region | `EXAMPLE-CL-REGION-A3` | `max_drag_uN` | `<=` | 50000000 | confidence `0.99`. Not enough to save the pack |
| `REQ-W-OWNER-12` | 12 | owner | `EXAMPLE-CL-OWNER-42` | `min_wall_um` | `>` | 8000 | comparator is not `>=` |

`EXAMPLE-PACK-02` has no drag requirement. A conflict on wall suppresses every other finding. Do not add a drag pass beside an unresolved wall.

---

## 8. Requirement record, citation record, assessment output

Canonical JSON, for every hash in this file: UTF-8, keys sorted at every object, separators comma and colon with no spaces, non-ASCII escaped, one trailing newline. In Python 3.11 that is `json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=True) + "\n"`. Arrays keep the order this file states. SHA-256 is the lowercase hex of those bytes. A hash that does not match is a failed build, not a warning. Pretty JSON in this file is for a person to read. Hash the canonical bytes, not the pretty text.

### 8.1 Requirement record

`REQ-W-OWNER` is the record. SHA-256 `ebc709ea3ff490ad14583a8abd3092df96ae192bf5dd75855df775cc803e7556`.

```json
{
  "clause": "4.2",
  "clause_id": "EXAMPLE-CL-OWNER-42",
  "comparator": ">=",
  "confidence": "0.99",
  "doc_id": "EXAMPLE-OWNER",
  "excerpt": "Lethal service wall shall be at least 8000 um.",
  "excerpt_sha256": "82d121eebd0ff985c69e4df5360efc085daa88f49ebff03f66cbac1eb11c8eed",
  "layer": "owner",
  "pack_id": "EXAMPLE-PACK-01",
  "page": 4,
  "parameter": "min_wall_um",
  "requirement_id": "REQ-W-OWNER",
  "revision": "B",
  "unit": "um",
  "value_int": 8000
}
```

`value_int` is an integer. A decimal is `value_missing` and the pack is blocked. Confidence is a two-decimal string. The runner compares hundredths as integers. `0.99` is 99. `field_confidence_min` `0.90` is 90. A confidence below the minimum drops that requirement and blocks the pack with `low_confidence`. Equal to the minimum is kept.

Any column whose name starts with `model_` is stripped before the record is hashed or stored. A non-blank stripped value increments `discarded_model_numbers`. The digits are not copied.

### 8.2 Citation record

One citation is one clause used as evidence for one requirement. The quote is the library text, not a paraphrase. SHA-256 of the owner spec citation is `79d4b38785fba633e431a70aba2e7a1b893266272dcaed2c65cb9c13d8ec8867`.

```json
{
  "clause": "4.2",
  "clause_id": "EXAMPLE-CL-OWNER-42",
  "doc_id": "EXAMPLE-OWNER",
  "kind": "spec",
  "page": 4,
  "quote": "Lethal service wall shall be at least 8000 um.",
  "quote_sha256": "82d121eebd0ff985c69e4df5360efc085daa88f49ebff03f66cbac1eb11c8eed",
  "requirement_id": "REQ-W-OWNER",
  "revision": "B"
}
```

On a pack that reaches findings, each kept requirement produces a `spec` citation from its own clause. Each `min_wall_um` requirement also produces a `standard` citation of `EXAMPLE-CL-WALL-W1`. Each `max_drag_uN` requirement also produces a `standard` citation of `EXAMPLE-CL-DRAG-D1`. Citations are sorted by `requirement_id`, then `clause_id`. A blocked pack and a conflict pack write `"citations": []`. A conflict is not evidence. A block is not evidence.

### 8.3 Assessment output

Keys, and no others: `assessment_type`, `calc`, `citations`, `codes`, `conflict`, `disagreement`, `discarded_model_numbers`, `findings`, `missing_layers`, `numbers_from_model`, `pack_id`, `product_id`, `released_to_customer`, `signed`, `signed_by`, `status`.

`numbers_from_model` is false on every fixture assessment. `released_to_customer` is false. `signed` is false and `signed_by` is `""` until section 13. `assessment_type` is `lethal_service_conformity`.

`status` is one of `ready_for_signoff`, `conflict`, `not_met`, `blocked`, and, only after a valid token, `signed`.

`calc` is null unless every gate in section 10 passed and a drag requirement remains. When present:

```json
{
  "force_uN": 47812500,
  "formula": "drag_force_uN",
  "inputs": {
    "area_mm2": 15000,
    "cd_milli": 1200,
    "rho_kg_m3": 850,
    "v_mm_s": 2500
  },
  "limit_uN": 50000000,
  "source": "reference_code"
}
```

`source` is `reference_code` and never `model`. `47812500` micronewtons is 47.8125 newtons. The limit `50000000` is 50 newtons. The comparison is `force_uN <= limit_uN`. The runner does not print the newton decimal into the file.

A wall finding has `disposition`, `parameter` `min_wall_um`, `requirement_ids` sorted, and `wall_um` from the product row. A drag finding has `disposition`, `limit_uN`, `parameter` `max_drag_uN`, `requirement_ids` sorted, and `value_uN` equal to `calc.force_uN`. Findings are sorted by `parameter`, so drag comes before wall.

---

## 9. Step by step

`assess_pack` walks one pack in this order. Later steps do not run when an earlier step has already returned.

1. **Layers.** For `owner`, `epc`, and `region`, the layer row must name a document that exists. A missing name, a blank id, or an unknown document appends that layer to `missing_layers` (sorted) and adds `layer_missing`. A document with `verified` other than `yes`, or with `page_count` under 1, adds `document_unverified`. On `mode` `fixture`, a `byte_sha256` that is not the hash of `{doc_id}:{revision}` adds `hash_mismatch`. If any of these codes fired, status is `blocked`, findings are empty, `calc` is null, and the function returns. Requirements are not judged. This is the annex rule.
2. **Strip model columns.** For each requirement, drop every column whose name starts with `model_`. A non-blank value increments `discarded_model_numbers`. Do not write the value anywhere in the assessment. `999` must not appear in `EXAMPLE-PACK-04`.
3. **Excerpt.** `excerpt_sha256` must equal SHA-256 of the excerpt UTF-8. Otherwise `excerpt_hash_invalid` for that requirement.
4. **Confidence.** Parse hundredths. Missing, malformed, or below `field_confidence_min` is `low_confidence`.
5. **Citation.** `clause_id` must be a library row. Otherwise `citation_missing`. The row's `text_sha256` must equal SHA-256 of its `text`. Otherwise `citation_mismatch`. The requirement's doc, revision, clause, and page must equal the clause row, except `REQ-X-3`, which fails on the missing id before that compare.
6. **Comparator and value.** `min_wall_um` allows only `>=`. `max_drag_uN` allows only `<=`. Anything else is `comparator_refused`. `value_int` must be an integer or the code is `value_missing`.
7. If any code was added in steps 3 through 6, status is `blocked`, findings stay empty, `calc` stays null, codes are the sorted unique set, and the function returns. One bad requirement blocks the pack. A good drag requirement does not rescue a low-confidence wall. That is `EXAMPLE-PACK-11`.
8. **Conflict.** Group kept requirements by `parameter`. If the set of `(comparator, value_int, unit)` has more than one member, the parameter is a conflict. `sides` are `{layer, requirement_id, value_int}` sorted by layer, then requirement id. Status is `conflict`, codes are `["layer_conflict"]`, the finding disposition is `unresolved`, and `calc` is null. Do not compare the product. Do not mark either side `met`.
9. **Code and arithmetic.** If a `max_drag_uN` requirement remains, run section 10. A `code_refused`, `calc_disagreement`, or `calc_not_exact` returns `blocked` with empty findings. Disagreement fills `disagreement` and leaves `calc` null.
10. **Compare.** Wall: `product.wall_um >= value_int`. Drag: `calc.force_uN <= limit`. One failure makes status `not_met` and codes `["not_met"]`. Findings stay, including a drag finding that met, so the engineer can see which check failed. All met: status `ready_for_signoff`, codes `[]`.

Blocked codes do not produce citations. Conflict does not produce citations. `ready_for_signoff` and `not_met` do.

---

## 10. Calculations in code

The case says the agent writes code for specialised calculations such as wake and drag force analysis. The wake analysis they ran is not published. This section registers one formula so a builder can test the gate. It is ordinary drag force. It is not Cosasco's analysis and not a substitute for a licensed calculation procedure.

```text
F_N = 1/2 * rho * v^2 * Cd * A
F_uN = rho_kg_m3 * v_mm_s * v_mm_s * cd_milli * area_mm2 / 2_000_000_000
```

`v = v_mm_s / 1000`, `Cd = cd_milli / 1000`, `A = area_mm2 / 1_000_000`, and `F_uN = F_N * 1_000_000`. Those substitutions reduce to the integer line above. The denominator is `2000000000`. If the numerator is not divisible by that denominator, return `calc_not_exact` and do not round.

For the fixture inputs the numerator divides evenly. The force is `47812500`.

`drag_force_uN_reference(850, 2500, 1200, 15001)` is not exact. The unit object is `{"code":"calc_not_exact","inputs":{"area_mm2":15001,"cd_milli":1200,"rho_kg_m3":850,"v_mm_s":2500}}`. SHA-256 `86762fba35db9df3b91684ac90ecce2cc383596ff711288c95be79e8a383e560`. This call is not part of `run_regression`.

The reference function lives in the runner. The script the model is allowed to write is only a call into a formulas module. The runner then executes that call and the reference. They must return the same integer.

`scripts/drag.py` is exactly these bytes, including the final newline:

```python
def run(formulas, inputs):
    return formulas.drag_force_uN(
        inputs["rho_kg_m3"],
        inputs["v_mm_s"],
        inputs["cd_milli"],
        inputs["area_mm2"],
    )
```

`check_code` parses that source with the Python `ast` module. It accepts the tree only when all of these hold:

- The module body is one function, named `run`, with arguments `formulas` and `inputs`, and no defaults, varargs, or keywords.
- The function body is one `return`.
- The return value is a call of `formulas.drag_force_uN` with four positional arguments and no keywords.
- The arguments are subscripts of `inputs` with the string keys `rho_kg_m3`, `v_mm_s`, `cd_milli`, `area_mm2`, in that order.
- No constant in the tree is an int or a float. The string keys are allowed. A numeric literal is `code_refused`.

`scripts/EXAMPLE-PACK-05.py` is:

```python
def run(formulas, inputs):
    return 47812500
```

That file is `code_refused` before it is executed. The correct force sitting in the script does not make it the answer. `EXAMPLE-PACK-05` has `calc` null.

When the tree is accepted, execute it with `__builtins__` empty, pass the formulas object and the product inputs, and compare the return to the reference. The fixture's good formulas object implements the same division. The fixture's bad formulas object, used only for `EXAMPLE-PACK-10`, returns `1` and ignores the inputs. The assessment then has `calc` null and:

```json
"disagreement": {"reference_uN": 47812500, "script_uN": 1}
```

`1` is stored only there, so an engineer can see the fight. It is not `force_uN`. A live pack cannot select the bad double. That row is `fixture_only` at startup when `mode` is `live`.

Wall thickness is a comparison, not a second formula. `wall_um >= value_int`. Both numbers are integers the company stored. The model does not estimate a thickness from a description.

---

## 11. Prompts

Version 1 does not call these prompts. `external_model` is `no`, and `assess_pack` does not read them. They are here so the later switch has a text to use, and so a builder does not invent a looser one.

Extraction. One document at a time. The tool context is `read_pack_text` and `lookup_clause` only.

```text
You extract requirement candidates from one spec document. You do not assess conformity. You do not calculate a force, a wall, a rate, or any other number. If you would write a digit that is not copied from the document, stop and leave value_int null.

Return a JSON array only. Each object has: layer, doc_id, revision, page, clause, parameter, comparator, value_int, unit, excerpt, confidence.

excerpt is copied from the document, character for character. confidence is your confidence in the excerpt boundary, as a two-decimal string from 0.00 to 0.99. It is not a conformity score. It is not 80 percent.

parameter is min_wall_um, max_drag_uN, or other. If it is other, value_int is null. comparator is >= or <= or empty. Do not invent a clause number. Do not quote ASME, ASTM, ISO, or API from memory. Do not write a column whose name starts with model_.
```

Calc. One formula at a time. If the registered formula is not on the list, the model returns the single line `NO_FORMULA` and the runner blocks with `code_refused` rather than accepting a new formula from the reply.

```text
You may write a Python function run(formulas, inputs) that returns formulas.drag_force_uN called with inputs["rho_kg_m3"], inputs["v_mm_s"], inputs["cd_milli"], and inputs["area_mm2"], in that order. You may not write a numeric literal. You may not return a force you computed yourself. If the formula is not drag_force_uN, return the single line NO_FORMULA and stop.
```

The runner parses that reply with section 10. A reply that fails the tree is discarded. The reference function still runs only when the tree passed and the script's return matches it. The model's own arithmetic is never the stored number.

A system line that is always in front of either prompt:

```text
You are not the signer. You do not say conforms, met, signed, or flawless. You do not choose between two specification layers. You do not invent a standard clause. Numbers are computed by the runner. If a tool result and a sentence in your training disagree, the tool result is the one you may quote, and only as an excerpt.
```

---

## 12. Worked fixture

Delete every `EXAMPLE` id before a live pack is read. These rows are not Cosasco specifications, not a Cassidy workspace, and not a valve anyone should manufacture.

`run_clock` is `2026-11-14T08:00:00Z`. `run_regression` assesses `EXAMPLE-PACK-01` through `EXAMPLE-PACK-12` in that order, writes `out/assessments/{pack_id}.json` for each, appends one audit line per pack, writes the morning file and the metrics file, and does not sign.

### 12.1 Pack 01, ready for sign-off

Owner and EPC both require a wall of at least 8000 micrometres. The product row has 9000. The region annex limits drag to 50000000 micronewtons. The reference returns 47812500, which is under the limit. Both standard cards are cited. SHA-256 `8eb58836130fe467d48c548fd898ecbbad3cf89f027e741b49baedf4a2111e4a`.

```json
{
  "assessment_type": "lethal_service_conformity",
  "calc": {
    "force_uN": 47812500,
    "formula": "drag_force_uN",
    "inputs": {
      "area_mm2": 15000,
      "cd_milli": 1200,
      "rho_kg_m3": 850,
      "v_mm_s": 2500
    },
    "limit_uN": 50000000,
    "source": "reference_code"
  },
  "citations": [
    {
      "clause": "D.1",
      "clause_id": "EXAMPLE-CL-DRAG-D1",
      "doc_id": "EXAMPLE-STD-DRAG",
      "kind": "standard",
      "page": 1,
      "quote": "Drag force is computed by drag_force_uN from the registered inputs. The limit comes from the spec pack.",
      "quote_sha256": "c83b6f94f42a7ddd743160b0ea4b6cb600c346fc8a2ba9186f959fcbc927748d",
      "requirement_id": "REQ-D-REGION",
      "revision": "1"
    },
    {
      "clause": "A.3",
      "clause_id": "EXAMPLE-CL-REGION-A3",
      "doc_id": "EXAMPLE-REGION",
      "kind": "spec",
      "page": 9,
      "quote": "Drag force shall not exceed 50000000 uN.",
      "quote_sha256": "12c4a2cf19cbd9268a5d81e217e52422835063beddfdfac8a06a7b28f6516786",
      "requirement_id": "REQ-D-REGION",
      "revision": "C"
    },
    {
      "clause": "2.1",
      "clause_id": "EXAMPLE-CL-EPC-21",
      "doc_id": "EXAMPLE-EPC",
      "kind": "spec",
      "page": 2,
      "quote": "Lethal service wall shall be at least 8000 um.",
      "quote_sha256": "82d121eebd0ff985c69e4df5360efc085daa88f49ebff03f66cbac1eb11c8eed",
      "requirement_id": "REQ-W-EPC",
      "revision": "A"
    },
    {
      "clause": "W.1",
      "clause_id": "EXAMPLE-CL-WALL-W1",
      "doc_id": "EXAMPLE-STD-WALL",
      "kind": "standard",
      "page": 1,
      "quote": "Minimum wall is an integer in micrometres on the product row. Compare it in code. Do not type the number.",
      "quote_sha256": "5b74410059453ea24ae5184caeaf1444cad6d7e20065df513f0a6fd12b311774",
      "requirement_id": "REQ-W-EPC",
      "revision": "1"
    },
    {
      "clause": "4.2",
      "clause_id": "EXAMPLE-CL-OWNER-42",
      "doc_id": "EXAMPLE-OWNER",
      "kind": "spec",
      "page": 4,
      "quote": "Lethal service wall shall be at least 8000 um.",
      "quote_sha256": "82d121eebd0ff985c69e4df5360efc085daa88f49ebff03f66cbac1eb11c8eed",
      "requirement_id": "REQ-W-OWNER",
      "revision": "B"
    },
    {
      "clause": "W.1",
      "clause_id": "EXAMPLE-CL-WALL-W1",
      "doc_id": "EXAMPLE-STD-WALL",
      "kind": "standard",
      "page": 1,
      "quote": "Minimum wall is an integer in micrometres on the product row. Compare it in code. Do not type the number.",
      "quote_sha256": "5b74410059453ea24ae5184caeaf1444cad6d7e20065df513f0a6fd12b311774",
      "requirement_id": "REQ-W-OWNER",
      "revision": "1"
    }
  ],
  "codes": [],
  "conflict": [],
  "disagreement": null,
  "discarded_model_numbers": 0,
  "findings": [
    {
      "disposition": "met",
      "limit_uN": 50000000,
      "parameter": "max_drag_uN",
      "requirement_ids": ["REQ-D-REGION"],
      "value_uN": 47812500
    },
    {
      "disposition": "met",
      "parameter": "min_wall_um",
      "requirement_ids": ["REQ-W-EPC", "REQ-W-OWNER"],
      "wall_um": 9000
    }
  ],
  "missing_layers": [],
  "numbers_from_model": false,
  "pack_id": "EXAMPLE-PACK-01",
  "product_id": "EXAMPLE-VALVE-1",
  "released_to_customer": false,
  "signed": false,
  "signed_by": "",
  "status": "ready_for_signoff"
}
```

### 12.2 Pack 02, the two layers disagree

Owner says 6000. EPC says 8000. The runner does not keep 8000 because it is stricter. SHA-256 `d12a1ec2c06d667798fcb0e1b8cded9a2d108cf9e223d91ea023b025f2efef89`.

```json
{
  "assessment_type": "lethal_service_conformity",
  "calc": null,
  "citations": [],
  "codes": ["layer_conflict"],
  "conflict": [
    {
      "parameter": "min_wall_um",
      "sides": [
        {"layer": "epc", "requirement_id": "REQ-W-EPC-2", "value_int": 8000},
        {"layer": "owner", "requirement_id": "REQ-W-OWNER-2", "value_int": 6000}
      ]
    }
  ],
  "disagreement": null,
  "discarded_model_numbers": 0,
  "findings": [
    {
      "disposition": "unresolved",
      "parameter": "min_wall_um",
      "requirement_ids": ["REQ-W-EPC-2", "REQ-W-OWNER-2"]
    }
  ],
  "missing_layers": [],
  "numbers_from_model": false,
  "pack_id": "EXAMPLE-PACK-02",
  "product_id": "EXAMPLE-VALVE-1",
  "released_to_customer": false,
  "signed": false,
  "signed_by": "",
  "status": "conflict"
}
```

### 12.3 Pack 07, the thin valve

Same limits as pack 01. `wall_um` is 5000, so the wall finding is `not_met` and the drag finding is still `met` at 47812500. Status `not_met`. Codes `["not_met"]`. SHA-256 `8758e34d37e30b53f4760b6f7aaf8c04e03b4d7489ada2282087897ada939eed`. Signing it returns `{"code":"sign_refused","pack_id":"EXAMPLE-PACK-07","status":"not_met"}`, SHA-256 `3ec5f5188996ee3e16aa0e021e1496fec6cd87f9b671ff4a5f5b5efc6e39f8e8`.

### 12.4 Pack 10, the script and the reference disagree

SHA-256 `3ce001dc9bdd864f091e52f5673c27259f6119a98aa8af7a9b196cad821d9d6a`.

```json
{
  "assessment_type": "lethal_service_conformity",
  "calc": null,
  "citations": [],
  "codes": ["calc_disagreement"],
  "conflict": [],
  "disagreement": {"reference_uN": 47812500, "script_uN": 1},
  "discarded_model_numbers": 0,
  "findings": [],
  "missing_layers": [],
  "numbers_from_model": false,
  "pack_id": "EXAMPLE-PACK-10",
  "product_id": "EXAMPLE-VALVE-1",
  "released_to_customer": false,
  "signed": false,
  "signed_by": "",
  "status": "blocked"
}
```

### 12.5 The other blocks

Each of these is the same shell as pack 10, with `disagreement` null, `discarded_model_numbers` 0, and the codes and missing layers below. Pack 04 is not a block. It matches pack 01's findings and force, with requirement ids `REQ-D-REGION-4`, `REQ-W-EPC-4`, and `REQ-W-OWNER-4`, and `discarded_model_numbers` 1. The digits `999` do not occur anywhere in that JSON.

| Pack | Status | What is different | SHA-256 |
| --- | --- | --- | --- |
| `EXAMPLE-PACK-03` | `blocked` | `codes` `["citation_missing"]` | `4b352bcaf5a710218af4c6f27f42056f975a7498504ccf7f6e77a3fa67ef67c9` |
| `EXAMPLE-PACK-04` | `ready_for_signoff` | discarded model number, force still 47812500 | `0cca1f22c6a12aa78d8549b00a3ca6c611d80db107ea10038766d27e15e5daae` |
| `EXAMPLE-PACK-05` | `blocked` | `codes` `["code_refused"]` | `ac8a5ed4930f36024d74dacacfb1be5c8d4ab05afd8a99f20c0505e7692b43dd` |
| `EXAMPLE-PACK-06` | `blocked` | `codes` `["excerpt_hash_invalid"]` | `2ab3611a6e0e80415814f446a8207af3cdde18b285947cca6a82993c8dc03edf` |
| `EXAMPLE-PACK-08` | `blocked` | `codes` `["layer_missing"]`, `missing_layers` `["region"]` | `0f28c6e2044f4b3278dc2eea7c1bd16e0e6a30aa26023ec4dee33337a03b271c` |
| `EXAMPLE-PACK-09` | `blocked` | `codes` `["document_unverified"]` | `e3be899e23094bd2ae1f8c674685ef8c11ac93dd3f6157904569f32b75841f5e` |
| `EXAMPLE-PACK-11` | `blocked` | `codes` `["low_confidence"]` | `8f530e0513fc5bb7e6744dcb3973ea9bf3281d2f578874a7d7ad42c15ccd85a0` |
| `EXAMPLE-PACK-12` | `blocked` | `codes` `["comparator_refused"]` | `a0d238a0a9cc9c0db9ebf8bb26661e21d18a945152295330a12efd862ab31364` |

---

## 13. Human sign-off

The engineer confirms before an assessment is signed, and a person, not this runner, sends it if anyone sends it. The customer story says the team reviewed the 17 pages and found no error. It does not print a token. The token is this file's design, because a clean first review is not a reason to skip the second one. "Flawless every time" does not clear the queue.

1. `assess_pack` sets `signed` false. `status` `ready_for_signoff` is the only status a token can move.
2. The engineer reads the assessment beside the three source documents and the product row. The form has two actions: sign, reject.
3. Sign requires a live token. The actor is the engineer. The backup may sign only when `backup` is not `none` and the token's actor is that id. The lead cannot sign an assessment. `EXAMPLE-LEAD` on pack 01 returns `{"code":"wrong_actor","pack_id":"EXAMPLE-PACK-01"}`, SHA-256 `403c8f814c8c11d883d804e8bb1f34cb1028e19040e56e5e7497e8b01704b840`.
4. Reject records `signed` false and `status` `rejected`. No customer file.
5. Opening the PDF is not a signature. A model sentence that says "signed" is `prompt_ignored`.
6. Signing one pack does not sign the next one.
7. Go-live is a different form. The lead signs it. The engineer cannot. After the lead signs, a person may set `write_signed` to `yes` and `shadow` to `no`. The agent does not.
8. There is no ninth step in which the runner emails a customer.

The token is lowercase hex HMAC-SHA256 of the UTF-8 string:

```text
sign|{pack_id}|{unsigned_assessment_sha256}|{exp}|{actor}
```

using `approval_key`. `exp` is `run_clock` plus `approval_ttl_hours`. Equal to `exp` is alive. After `exp` is `token_dead`, and the assessment stays unsigned.

For the fixture, the key is `example-approval-key`, the unsigned hash is `8eb58836130fe467d48c548fd898ecbbad3cf89f027e741b49baedf4a2111e4a`, `exp` is `2026-11-14T16:00:00Z`, and the actor is `EXAMPLE-ENGINEER`. The message is:

```text
sign|EXAMPLE-PACK-01|8eb58836130fe467d48c548fd898ecbbad3cf89f027e741b49baedf4a2111e4a|2026-11-14T16:00:00Z|EXAMPLE-ENGINEER
```

The token is `68eeafd584f41c8da7c7060483b028b1d1d6c280568eb71c414c88e34312167f`.

After that signature, at a `run_clock` at or before `exp`, the assessment is the pack 01 object with `signed` true, `signed_by` `EXAMPLE-ENGINEER`, and `status` `signed`. Every other field is unchanged, including `released_to_customer` false and `force_uN` 47812500. SHA-256 `d7c4a611e2ffc9d01f558d45759ef999e81921ea25e58fe17689e13c2a9ca84c`.

`engineer_signoff_required` cannot be set to `no`. There is no unattended path in version 1.

---

## 14. Logging, morning file, metrics

Append one JSON object per line to `out/audit.jsonl`, in pack order. Do not delete lines. The pack 01 line is:

```json
{
  "action": "assess",
  "actor": "EXAMPLE-AGENT",
  "at": "2026-11-14T08:00:00Z",
  "codes": [],
  "pack_id": "EXAMPLE-PACK-01",
  "result": "ready_for_signoff"
}
```

SHA-256 `6c09b6ae82349939bab058efa342fb457d932aa1add8b33793c92f4cea547d3b`. `at` is `run_clock`. `actor` is `agent_id`. `result` is the status. `codes` is the assessment's codes.

The morning file is `out/daily_summary.json` for the twelve packs before any signature. `not_met` counts assessments with that status, once. It is not also incremented because the code is `not_met`. `layer_conflict` counts the code. `conflict` counts the status. Both are 1 on this run. `ready_for_signoff + conflict + not_met + blocked` equals `packs_seen`.

```json
{
  "blocked": 8,
  "calc_disagreement": 1,
  "citation_missing": 1,
  "code_refused": 1,
  "comparator_refused": 1,
  "conflict": 1,
  "discarded_model_numbers": 1,
  "document_unverified": 1,
  "excerpt_hash_invalid": 1,
  "layer_conflict": 1,
  "layer_missing": 1,
  "low_confidence": 1,
  "not_met": 1,
  "numbers_kept_from_model": 0,
  "packs_seen": 12,
  "ready_for_signoff": 2,
  "released_to_customer": 0,
  "signed": 0
}
```

SHA-256 `4908a601cacfc4b13b110238bcd185474a08ff9732efe109bb42703e296d9b78`.

The morning file has no key named `target`, `eighty`, `hours`, `cosasco`, `flawless`, or `pages`. A sentence under it that quotes the case study's rates is deleted. `numbers_kept_from_model` and `released_to_customer` are present so a non-zero value is obvious. Version 1 has no statement that increments either one.

`out/metrics.json` on the fixture run, with no `timing.csv`, `edits.csv`, or `late.csv`:

```json
{
  "edit_denom": 0,
  "edit_numer": 0,
  "late_denom": 0,
  "late_numer": 0,
  "minutes_denom": 0,
  "minutes_numer": 0
}
```

SHA-256 `1c130cd3d505ae06b42a71bdf04302e10c2021e9d66aba6ae237b0b99ca7af99`.

Do not divide in the file. A function that returns a percent has failed.

---

## 15. Workflows that stay locked

`run_workflow("EXAMPLE-PACK-01", workflow)` returns one of these and writes nothing.

| workflow | SHA-256 |
| --- | --- |
| `bid_comparison` | `0166e4efd47c34eb0b72c5a37f7b919eb6e0d2c3852d773f675a6ea144e6ec93` |
| `inspection_test_plan` | `0ba7b0adeeaf439ca9ba02980f4034bdcab18e515facfd7975f89250491153a6` |
| `field_report` | `6a53434aa59e7f056f2430fac5eb941ed292bf09cae433e6eb5d7fea5a92b8fd` |
| `coupon_analysis` | `5d51aacdf9b32da3c6ac79100a3cd7f90051194d721302e0403ad9202966c540` |

Each object is `{"code":"scope_locked","pack_id":"EXAMPLE-PACK-01","workflow":"<name>"}`.

When a later phase enables one, the shapes are fixed now so the builder does not invent them under a deadline.

Bid discrepancy, one row per mismatch, never a model verdict:

```json
{
  "bid_excerpt_sha256": "",
  "bid_line_id": "",
  "disposition": "mismatch",
  "requirement_id": "",
  "spec_quote_sha256": ""
}
```

Inspection-test-plan row. The $600,000 order had hundreds of lines. That count is theirs. A later phase starts with one assessment's requirements, not with hundreds. `inspector_result` starts as `""`. The agent does not write `pass`.

```json
{
  "citation_ids": [],
  "inspector_result": "",
  "justification_quote_sha256": "",
  "line_no": 1,
  "pack_id": "",
  "requirement_id": "",
  "signed_by": ""
}
```

Field report. Readings are integers the technician typed into `readings.csv` as `name,value_int,unit`. The draft may mention a reading only by copying that integer. Any other integer in the draft is `reading_invented`, and the file is not offered as the report.

Coupon. `mass_loss_mg(before_mg, after_mg)` returns `before_mg - after_mg` when both are integers and `after_mg` is less than or equal to `before_mg`. Otherwise `mass_data_refused`. No rate, no area, and no model subtraction in the first version of that workflow. The case says the team extended the platform to coupon analysis. It does not publish the formula. Do not invent a corrosion rate and attribute it to them.

---

## 16. Evaluation set and go-live

`golden.csv` is a person labeling packs the company has already assessed by hand. The agent does not label its own set. The fixture file is:

```text
pack_id,expect,detail
EXAMPLE-PACK-01,ready_for_signoff,47812500|9000|0
EXAMPLE-PACK-02,conflict,min_wall_um|6000|8000
EXAMPLE-PACK-03,blocked,citation_missing
EXAMPLE-PACK-04,ready_for_signoff,47812500|9000|1
EXAMPLE-PACK-05,blocked,code_refused
EXAMPLE-PACK-06,blocked,excerpt_hash_invalid
EXAMPLE-PACK-07,not_met,min_wall_um|5000|8000
EXAMPLE-PACK-08,blocked,layer_missing
EXAMPLE-PACK-09,blocked,document_unverified
EXAMPLE-PACK-10,blocked,calc_disagreement
EXAMPLE-PACK-11,blocked,low_confidence
EXAMPLE-PACK-12,blocked,comparator_refused
```

A row passes when `status` equals `expect` and the detail matches. Ready detail is `force_uN|wall_um|discarded_model_numbers`. Conflict detail is `parameter` plus the side values sorted ascending, joined by `|`. Blocked detail is the single code. Not-met detail is `min_wall_um|wall_um|agreed_minimum`. A changed digit fails. There is no partial credit. The SHA-256 table in section 12 must also match. A detail pass with the wrong hash has failed.

Go-live, all of them, before `write_signed` may be `yes` on a live desk:

- `mode` is `live`. Fixture mode returns `fixture_go_live_refused`.
- Active golden rows are at least `golden_min`, and `golden_min` is at least 30.
- Every active row passes detail and hash.
- The lead has signed, and `go_live_approved_by` equals the lead.
- `numbers_kept_from_model` and `released_to_customer` are zero.
- A person has read ten assessments beside the source packs and written those ten pack ids into `reviewed.csv`. The ten is our design.

Missing any one, the flag stays `no`. A golden pass does not sign a live pack.

The published 80 percent is recorded above so nobody has to hunt for it. It is refused if someone pastes it into `field_confidence_min` or into a config key named in section 3. A company whose own minutes land near that ratio still keeps the engineer on the signature. `0.90` is our suggestion for extraction confidence. It is not a result from the case.

---

## 17. Failure handling

| What happened | Code | What the runner does |
| --- | --- | --- |
| A required layer file was never ingested | `layer_missing` | Block. No `met` finding. Name the layer |
| The file is present and not verified, or the page count is 0 | `document_unverified` | Block |
| The excerpt hash does not match the excerpt | `excerpt_hash_invalid` | Block. Do not use the requirement |
| The clause id is not in the library | `citation_missing` | Block. Do not recite the standard from memory |
| The clause text does not match its stored hash | `citation_mismatch` | Block |
| The model filled a force column | stripped | Increment `discarded_model_numbers`. Continue only if nothing else failed. Do not store the digits |
| Two layers disagree | `layer_conflict` | Status `conflict`. Show both. Do not pick |
| The script contains a number or the wrong shape | `code_refused` | Block. Do not execute it |
| The script and the reference disagree | `calc_disagreement` | Block. Store both integers under `disagreement` only |
| The division is not exact | `calc_not_exact` | Block. Do not round |
| The product fails a comparison the layers agreed | `not_met` | Keep the findings. Refuse to sign |
| Someone calls the ITP, the bid check, the field report, or the coupon path | `scope_locked` | Write nothing |
| The lead tries to sign the technical assessment | `wrong_actor` | Leave it unsigned |
| A token is late | `token_dead` | Leave it unsigned |

A failure is a file. It is not an email. It is not a retry that drops the region layer to make the pack pass.

---

## 18. Rollout

Ninety days. This calendar is our design. The customer story does not print how long the build took. That silence is not this schedule.

Days 1 to 30. One assessment type. One product family. Ingest owner, EPC, and region, and record the file hash and `verified`. Extract requirement candidates into the CSV. The engineer compares them to a pack the company already finished by hand. `assess_pack` may run. Nothing is signed. A missing region stays a blocked pack, on purpose.

Days 31 to 60. The reference calc runs beside the engineer's own number. Disagreements, conflicts, and low-confidence excerpts are the work. The engineer still does the assessment the way they did it before. The queue may not be cleared by deleting a layer.

Days 61 to 90. If the golden set passes and the lead has signed go-live, the engineer may sign a `ready_for_signoff` assessment. The runner still does not send it. ITP, bid comparison, field reports, and coupon analysis stay `scope_locked`. The next workflow, when a person writes it down, is one of those four, with the same citation rule and the same refusal to let a model type a number. The story's order was the conformity assessment first. Follow that, not all four at once.

Weekly usage by team and by person is a report the company already found useful. Version 1's morning file is the count of packs and codes. It is not a leaderboard against the case study. People adopt this because it sits on the assessment they already have to finish. A mandate is not a config key.

---

## 19. KPIs

Track these. Do not replace them with the published ratio.

| KPI | Where it comes from | What a bad reading looks like |
| --- | --- | --- |
| Minutes per pack | `timing.csv`, written by a person | A target of 8, or a percent of 80, stored in config |
| Engineer edits | `edits.csv` | Edits falling because the queue was turned off |
| Citation failures | `citation_missing` plus `citation_mismatch` plus `excerpt_hash_invalid` | A library that grows by model paraphrase |
| Calc disagreements | `calc_disagreement` | A builder who deletes the reference to make the script win |
| Layer blocks | `layer_missing` plus `document_unverified` | A pack signed with two layers because the annex was late |
| Conflicts left unresolved | `conflict` | An automatic `strictest_wins` someone added |
| Late finds after manufacturing | `late.csv` | Treating zero as a property of the model |
| Questions the agent answered | a count the company keeps, as two integers | Pasting "more than 50 percent" onto a proposal |
| Released by the agent | `released_to_customer` | Anything but zero |

The 40 hours, the 8 hours, the five-to-one, the 80 percent, the one day against three or four, and the $600,000 order are Cosasco's published story. They are the reason this file exists. They are not this company's forecast.

---

## 20. Risks

- **A fluent standard.** The model knows the names ASME, ASTM, ISO, and API and will quote them when the library is empty. The quote will look like a citation. Mitigation: `standards_from_memory` is `no`, a missing clause blocks, and the quote hash has to match a row a person loaded.
- **A typed force.** The 17-page story is about calculations. A model that writes the number and the sentence around it will look like that story. Mitigation: numeric literals are refused, `model_` columns are stripped, and the stored force comes from the reference or from nowhere.
- **The missed annex, automated.** The original failure was a site requirement found after manufacturing. A runner that assesses the layers it has, and stays quiet about the one it does not, repeats that failure faster. Mitigation: three layers are required, and a missing one blocks with no `met` finding.
- **Silent stricter-wins.** Picking 8000 over 6000 feels conservative and is still a choice the engineer did not make. Mitigation: `conflict_policy` is `engineer`, and both values are in the file.
- **The clean first review.** Pack 01 is ready to sign. That is not "not a single mistake" as a permanent property. The next pack can be the thin valve, the conflict, or the missing region. Mitigation: one token per pack, `not_met` cannot be signed, and the lead cannot sign for the engineer.
- **Licensed text in a prompt.** Loading a standard the company has not licensed, or pasting it into a vendor prompt, is a different problem from a wrong hash. This file does not do that. The buy path and the build path both have to be told which documents may be stored.
- **Scope creep from the success story.** ITP, bids, field reports, and coupons are in the story because the first assessment worked. Turning them on in week one copies the ending and skips the test. Mitigation: `scope_locked`, and section 18's order.
- **A copied scoreboard.** Eighty percent in `field_confidence_min` would drop real excerpts and keep the ones the model liked. The startup refusal is there so that number cannot be a setting.
- **Language.** The source says people ask in their own language and get English back. Version 1 does not translate. A gloss is a person's row. A translated integer is a different requirement, and it waits.
- **The fixture as a product.** `EXAMPLE-VALVE-1` is a hash fixture. Building hardware from it, or treating 9.000 mm as a Cosasco wall, is a misuse. The file says so because the hashes are specific enough to look real.

---

## 21. Costs, and the choice to buy

Two paths. The gates in this file belong on both.

**Buy.** Cassidy is the no-code platform Cosasco used. The vendor's team helped build, test, and refine from the first day, which is the reason they gave for choosing it over a longer engineering build, and over tools that could only retrieve a prior answer. A company that wants that path buys the platform, puts the standards it is allowed to store into the knowledge base, turns on document verification, and keeps an engineer on the signature. Buying it does not make 80 percent a setting, and it does not remove the rule that a force comes from code.

**Build.** Python 3.11 or newer. The standard library only: `csv`, `json`, `hashlib`, `hmac`, `ast`. No PDF library and no HTTP client on the path `run_regression` runs. The model, if one is added after go-live, is allowed the three read tools in section 6 and one call per pack. The runner holds `assess_pack` and `sign_assessment`.

The expensive month is not the model. It is getting the three layers, the clause rows, and the product integers out of people's heads and into files a hash can refuse. An empty library will not produce the 17-page result. The file spends the first month on that library. One assessment type. One product family.

Do not budget the published $600,000, and do not staff toward the published 40 hours, inside this folder. Those figures are the success story's account of Cosasco.

---

## 22. Stack the tests lock

Python 3.11 or newer. Standard library only. Functions named in section 6, plus `verify_clause`, `drag_force_uN_reference`, `check_code`, and `mass_loss_mg`, are the API. A notebook that cannot be called as those functions is not an implementation.

`run_regression` writes the twelve assessments, the audit, the morning file, and the metrics file. It does not sign. It does not write a customer deliverable. The signature test is a separate call with the token in section 13.

---

## 23. What you do not claim

- Do not say this company will save 80 percent of engineering time. That sentence is Cosasco's published result, where the work was applicable. It is not a quotation for this company. It is not `field_confidence_min`.
- Do not say a lethal-service assessment will take 8 hours, or that it used to take 40. Those are the figures on the vendor's page for their valve assessment and their H1 assessment. They are not a latency budget.
- Do not say the output will be 17 pages, or that a review will find no error, because the first review found none. Keep the block codes. Count late finds the company writes down.
- Do not say the agent is flawless. That word is in a quotation. It is not a test result.
- Do not say more than half of routine questions will move on day one. That is their later result. Version 1 does not answer a free-form question. It assesses one pack.
- Do not say an inspection test plan will drop from three or four days to one, or that a $600,000 order is the pilot. The ITP workflow returns `scope_locked`.
- Do not say the agent picks the stricter specification. It shows the conflict.
- Do not say the agent signs, or that the customer has accepted the file, because a previous customer accepted one. `released_to_customer` stays false.
- Do not say this company will be live in the time Cosasco took. The story does not print that duration. Section 18 is ninety days, and it is ours.
- Do not say Cassidy is required as a product install, and do not say this file is Cassidy. The case used the no-code platform. This plant types its own files, or it buys that platform and keeps these gates.
- Do not say wake-and-drag analysis has been reproduced. The fixture force is textbook drag on made-up inputs. Their analysis was not published.
- Do not paste a licensed standard into the prompt from memory, and do not call the fixture sentences a standard.
- Do not say "around a hundred people" is this company's size, or a reason to skip a hire. The phrase is about Cosasco, from a third-party profile. The story's point on attrition is theirs. It is not a hiring plan.
- Do not paste this desk onto the ROBEL guide, or that guide onto this one. Different documents, different signature, no tender module here.

When a sentence would make this company sound like the case study's scoreboard, delete the sentence and show the company its own `timing.csv` instead.

---

## 24. Paste this to build it

Paste the block below to the agent that will build the tool. The builder reads this whole file. The model sees a spec pack only as data. It does not see a customer specification as instructions to follow against the company.

```text
You are building the engineering-assessment tool specified in engineering-assessment-agent-instructions.md. Build only what that file specifies.

Stack: Python 3.11 or newer. Standard library only. CSV with the headers in section 7. Assessments with the schema in section 8. Put the rules in pure functions assess_pack, verify_clause, check_code, drag_force_uN_reference, sign_assessment, run_workflow, run_regression, and daily_summary. Call them from a thin folder runner and from the tests. Do not reimplement the rules in the model prompt.

Fail closed. If any required config value is missing, blank, or the word REPLACE, do not serve a live run. If any id in a live folder starts with EXAMPLE, do not serve a live run. If assessment_type is not lethal_service_conformity, refuse to start. If numbers_from_model is not no, refuse to start. If engineer_signoff_required is not yes, refuse to start. If release_to_customer is not no, refuse to start. If standards_from_memory is not no, refuse to start. If conflict_policy is not engineer, refuse to start. If a confidence threshold is 0.80, 80, or 80%, refuse to start. If a model tool is named assess_pack, sign_assessment, run_calcs, release_to_customer, or write_standard, refuse to start.

The model tool list is read_pack_text, lookup_clause, and lookup_product. assess_pack and sign_assessment are runner functions. A model call to sign or calculate is prompt_ignored. Never set signed true without a live engineer token. Never set released_to_customer true. Never store 999. Never mark met when region is missing. Never pick 8000 over 6000. Never execute a script that returns 47812500 as a literal. Never let the bad formulas double win: script_uN 1 stays inside disagreement, and calc stays null. Never email a customer. A not_met assessment never takes the signature.

The fixture must produce pack 01 hash 8eb58836130fe467d48c548fd898ecbbad3cf89f027e741b49baedf4a2111e4a, pack 02 hash d12a1ec2c06d667798fcb0e1b8cded9a2d108cf9e223d91ea023b025f2efef89, pack 04 hash 0cca1f22c6a12aa78d8549b00a3ca6c611d80db107ea10038766d27e15e5daae, pack 07 hash 8758e34d37e30b53f4760b6f7aaf8c04e03b4d7489ada2282087897ada939eed, pack 10 hash 3ce001dc9bdd864f091e52f5673c27259f6119a98aa8af7a9b196cad821d9d6a, requirement hash ebc709ea3ff490ad14583a8abd3092df96ae192bf5dd75855df775cc803e7556, citation hash 79d4b38785fba633e431a70aba2e7a1b893266272dcaed2c65cb9c13d8ec8867, morning hash 4908a601cacfc4b13b110238bcd185474a08ff9732efe109bb42703e296d9b78, metrics hash 1c130cd3d505ae06b42a71bdf04302e10c2021e9d66aba6ae237b0b99ca7af99, and audit hash 6c09b6ae82349939bab058efa342fb457d932aa1add8b33793c92f4cea547d3b. The engineer token is 68eeafd584f41c8da7c7060483b028b1d1d6c280568eb71c414c88e34312167f and the signed assessment hashes to d7c4a611e2ffc9d01f558d45759ef999e81921ea25e58fe17689e13c2a9ca84c. Section 12 must pass before a lead is asked to turn write_signed on, and before a file is treated as an assessment the customer has already accepted.
```
