Read the Legacy System Before You Touch It
Updated
IntermediateWhat you'll learn
~55 min- Prompt an AI CLI to write a rules file where every rule cites file:line or a procedure name, and an unknowns file for everything it could not ground in source
- Apply citation-or-unknown, the discipline that keeps an AI from inventing plausible business logic, and prove it with a seeded rule that exists only in the prompt
- Record a golden corpus (inputs paired with the outputs the legacy system actually produced) from a restored copy, changing no production code
A case-intake office at a mid-sized agency runs on a 2000s-era app: classic ASP pages, SQL Server stored procedures, and a priority rule that lives partly in a scanned PDF desk guide. The office is rebuilding it on the reference app (Next.js, any OIDC provider, SQL Server, containers; lessons 34–37 land it on your cloud and code host) as an intake feature. Before anyone writes that feature, you need to know what the old system does, in writing, with a source for every claim.
An AI CLI reads old code quickly, and that speed has a failure mode: asked “what are the business rules?”, it produces a fluent, well-organized answer that contains rules the source never states. The rule sounds right, so nobody checks it, and the new system ships it. This lesson makes the agent produce two files instead of one, and makes a script refuse the first.
Before the detail — Artifact: rules.md (every rule cited), unknowns.md (everything the agent could not ground), and a golden corpus recorded from a restored copy of the running system; none of it touches production code. Acceptance test: a rule that exists only in your prompt lands in unknowns.md, and check-rules.sh exits non-zero when any citation does not resolve. Status: reusable guidance; the file layout and rule IDs are this module’s, and lesson 23 consumes them.
This lesson does not re-teach the method. Cloud Modernization Patterns (a separate training in this series) lesson 5.2 covers characterization tests before a port, with legitimate output differences listed one by one; its lesson 1.2 covers assessing the application and deciding whether to modernize at all. This lesson assumes that decision is made and supplies the government-typical inputs: ASP and stored procedures, with part of the rule in a document nobody can grep.
A sanctioned development environment is not a CUI determination (CUI is controlled unclassified information, data that law or policy says must be protected). Get the determination in writing from your CUI program manager or ISSO (the security officer who signs off on your system’s controls), as lesson 01 of this module sets out. Everything below works on source code, the desk guide, and synthetic inputs you invent; none of it needs a real case record.
What the office actually has
Three artifacts hold the rules. You will give the agent a read-only snapshot as modernization/legacy/, with line numbers intact, because line numbers are the citations.
The file legacy/web/submit.asp excerpt below computes a priority score before calling the database:
LEGACY SAMPLE · BEING REPLACED legacy/web/submit.asp: classic ASP intake submission page open reference hide reference Legacy sample file under modernization (not a pattern to copy); open to inspect what your agent reads and replaces.
1 <%@ Language="VBScript" %> 2 <!-- #include file="inc/db.asp" --> 3 <% 4 Dim caseType, hhSize, daysWaiting, score 5 caseType = UCase(Trim(Request.Form("case_type"))) 6 hhSize = CInt(Request.Form("household_size")) 7 daysWaiting = CInt(Request.Form("days_waiting")) 8 9 ' priority score10 score = 211 If caseType = "EMERGENCY" Then score = score + 412 If hhSize >= 5 Then score = score + 113 score = score + Round(daysWaiting / 20)14 If score > 10 Then score = 101516 Set cmd = Server.CreateObject("ADODB.Command")17 cmd.ActiveConnection = conn18 cmd.CommandText = "usp_SubmitIntake"19 cmd.CommandType = 420 cmd.Parameters.Append cmd.CreateParameter("@CaseType", 200, 1, 20, caseType)21 cmd.Parameters.Append cmd.CreateParameter("@Score", 3, 1, , score)22 cmd.Parameters.Append cmd.CreateParameter("@SubmittedBy", 200, 1, 50, Session("user"))23 Set rs = cmd.Execute24 Response.Write rs("CaseId") & "|" & rs("Status") & "|" & score25 %>The legacy stored procedure legacy/sql/usp_SubmitIntake.sql (a reference excerpt from the sample system under modernization that your agent reads from modernization/legacy/) has two side effects the page never mentions:
1 CREATE PROCEDURE dbo.usp_SubmitIntake 2 @CaseType VARCHAR(20), @Score INT, @SubmittedBy VARCHAR(50) 3 AS 4 BEGIN 5 DECLARE @Status VARCHAR(20) = 'NEW'; 6 IF @Score >= 7 SET @Status = 'FAST_TRACK'; 7 INSERT dbo.Intake (CaseType, Score, Status, SubmittedAt) 8 VALUES (@CaseType, @Score, @Status, SYSDATETIME()); 9 DECLARE @CaseId INT = SCOPE_IDENTITY();10 INSERT dbo.IntakeAudit (CaseId, Action, Actor, At)11 VALUES (@CaseId, 'SUBMIT', @SubmittedBy, SYSDATETIME());12 SELECT @CaseId AS CaseId, @Status AS Status;13 ENDAnd the legacy desk guide file, scanned in 2009 and run through OCR into legacy/docs/desk-guide.ocr.txt in the sample snapshot (the scan stays next to it; OCR text is a reference excerpt for your agent to read, and a misread digit is an unknown, not a rule):
1 INTAKE DESK GUIDE, rev. 2009 (scanned; OCR text, page breaks marked) 2 --- page 4 --- 3 3.2 Priority. Score every intake from 2. Emergency cases add 4. 4 Households of five or more add 1. Add one point per twenty days 5 waiting, rounded to the nearest whole point. The score never 6 exceeds 10. 7 3.3 Fast track. Scores of 8 or more go to the fast-track queue 8 the same day. Rural-county exceptions: see the county memo. 9 --- page 5 ---10 3.4 Every submission is logged to the audit table with the11 caseworker's login.Read them against each other and the traps are already visible: the desk guide says fast track starts at 8 and the procedure says 7; “rounded to the nearest whole point” says nothing about a half; line 8 points at a memo that is not in the repository; and line 2 of the page includes a file that is not in the snapshot.
The failure mode, stated plainly
Ask an agent for “the business rules of this module” and it will help. It will also add: veterans get an extra point, rural counties get a bump, applications over a year old escalate. Each is a plausible rule for a case-intake office and each is missing from the source. The model is completing a pattern, not reading a file.
The countermeasure is a contract with two outputs and no third place for a claim to hide:
- citation-or-unknown. A statement about behavior goes in
rules.mdonly with a citation that resolves:path:line, orproc:namefor a whole stored procedure. A statement that cannot be cited goes inunknowns.mdwith what would settle it and who to ask. - The agent may not resolve a conflict. Where two sources disagree, both citations go in the unknowns file. Which one is right is a business decision.
- Side effects are rules too. Every writing statement (insert, update, status flip, audit row) is listed against its rule, because the new feature must reproduce the writes, not only the return value.
Plan the change with your agent
Start your agent in the project root and switch to Plan mode (Shift+Tab, /plan, or the mode picker in your desktop app). Ask it to read the legacy snapshot in modernization/legacy/ and plan two files, modernization/rules.md and modernization/unknowns.md:
Read modernization/legacy/ without editing anything, and plan modernization/rules.md for cited business rules and modernization/unknowns.md for conflicts, missing files, or unsourced behavior. Ask me anything unclear before writing files.What to check in the plan before you approve
modernization/rules.mdis a Markdown table with columnsID | Rule | Citation | Side effects(R-01,R-02, … in source order), quoting exact operators or constants (score >= 7) and listing everyINSERT/UPDATE/DELETEor status change (noneif none).- Every rule carries one or more resolvable citations (
path:linerelative tomodernization/, orproc:ProcedureName, separated by semicolons). modernization/unknowns.mdlistsU-01,U-02, … for anything told or inferred without a source line, any conflict between two sources (citing both without picking one), any missing included file or memo, and runtime-dependent behavior (like.5tie rounding), along with what would settle it and who would know.- Doubt routes to
unknowns.mdby default, because a wrong entry inrules.mdis worse than a missing one.
If the agent’s plan picks one threshold for the fast-track conflict between the stored procedure (>= 7) and the desk guide (8 or more), correct it before approving:
Keep R-06 at score >= 7 from proc:usp_SubmitIntake, and record the conflict with desk-guide:7 as U-01 in unknowns.md without choosing between them.Routing doubt to the unknowns file keeps the contract strict. Reviewers read unknowns.md as the to-do list for the business owner, so an over-full unknowns file costs a meeting; an invented rule costs a wrong decision for every applicant.
When there is more than one module
One agent reading a whole legacy estate fills its context with code from one module while it is judging another, and the citations drift. Split the reading and keep the contract. Open the session, switch to plan mode inside it (Shift+Tab or /plan), and approve the plan before anything is written; the keys are the same in all four tools. Then give each legacy module (here: the submit page, the stored procedure, the desk guide) to its own subagent (a helper session with its own context window that reports back to the main session), and tell each to write only its own section of the inventory, modernization/inventory/<module>.md, under the same citation-or-unknown rule. A single merge pass then reads the sections together and does the one job no section can do alone: it reconciles them, so a threshold the procedure states one way and the desk guide another becomes a cross-module entry in unknowns.md rather than whichever claim the merge read last.
The merge pass may not add a rule. It copies cited rows into rules.md, copies unknowns into unknowns.md, and writes both citations wherever two sections disagree. check-rules.sh runs on the merged files, so a section that smuggled in an uncited rule fails there. Module 19 lesson 5 (subagent, then background, then worktree ladder) teaches the orchestration itself; this lesson adds only the rule that a subagent’s output is a draft until the checker passes.
One equivalents line for where a custom subagent definition lives: Claude Code .claude/agents/<name>.md; Codex .codex/agents/<name>.toml; Antigravity .agents/agents/<name>.md; Copilot .github/agents/<name>.agent.md. Lesson 02 holds the dated four-tool table; check it before you copy a spelling.
Watch it work
- Typed in the terminal:
claude - Mode:Plan mode (Shift+Tab)
- You type in the session: Read modernization/legacy/ without editing anything, and plan modernization/rules.md for cited business rules and modernization/unknowns.md for conflicts, missing files, or unsourced behavior. Ask me anything unclear before writing files.
- The tool replies: I read legacy/web/submit.asp, legacy/sql/usp_SubmitIntake.sql, and legacy/docs/desk-guide.ocr.txt. I found 7 cited rules and 6 open questions, including a fast-track conflict (proc says >= 7, desk guide says 8) and VBScript Round() tie behavior. Should rules.md use ID | Rule | Citation | Side effects and record the 7-vs-8 conflict in unknowns.md?
- You type in the session: Yes. Use path:line or proc:Name citations, keep R-06 at >= 7 from the procedure, and put the conflict in unknowns.md. Approved to write both files.
- The tool replies: Reading legacy/web/submit.asp, legacy/sql/usp_SubmitIntake.sql, legacy/docs/desk-guide.ocr.txt. Wrote modernization/rules.md (7 rules): R-01 score starts at 2 submit.asp:10 R-02 emergency adds 4 (after Trim+UCase) submit.asp:5, submit.asp:11; desk-guide:3 R-03 household >= 5 adds 1 submit.asp:12 R-04 adds Round(daysWaiting / 20) submit.asp:13 R-05 score capped at 10 submit.asp:14 R-06 status FAST_TRACK when score >= 7 proc:usp_SubmitIntake [writes dbo.Intake] R-07 audit row on every submission proc:usp_SubmitIntake [writes dbo.IntakeAudit] Wrote modernization/unknowns.md (6 entries): U-01 fast-track threshold: proc says 7 (usp_SubmitIntake.sql:6), desk guide says 8 (desk-guide:7). Not resolved. U-02 rural-county exceptions: desk-guide:8 refers to 'the county memo'. Memo not in legacy/. U-03 inc/db.asp (submit.asp:2) is not in legacy/. It may log, set session state, or change the connection. U-04 Round() on a half (10 days = 0.5, 50 days = 2.5): desk guide says 'nearest whole point' (desk-guide:4-5) and is silent on ties; the result depends on the runtime's rounding mode. Settle with the golden corpus. U-05 non-numeric household_size or days_waiting: CInt raises a runtime error; the response is not visible in source. U-06 the procedure has no explicit transaction; behavior if the audit insert fails after the intake insert is not visible in source.
- You type in the session: The office manager also told me veterans get +1 priority. Add that rule.
- The tool replies: I searched legacy/ for 'veteran', 'vet', and for any form field or column that could carry it. Nothing in submit.asp, usp_SubmitIntake.sql or the desk guide mentions it, and the page reads only case_type, household_size and days_waiting. I have not added it to rules.md. Added to unknowns.md: U-07 'veterans get +1 priority' - stated in the prompt, no source. Settle with: the office manager (is it practice, or policy, or older than this code?) and the county memo (U-02) if it is there.
- You type in the session: Then add the rural-county exceptions from the desk guide.
- The tool replies: desk-guide:8 says 'see the county memo' and gives no rule. I can't state what the exceptions are, so there is nothing to add to rules.md. U-02 already records the pointer; I added 'who to ask: the intake supervisor who holds the county memo'.
- Typed in the terminal:
bash modernization/scripts/check-rules.sh veteran - The tool replies: check-rules: ok
Illustrative session; exact output varies by tool and agency configuration.
What the two files should look like
Here is the reference rules.md table from gov-dev-reference-app, in the table form the check script reads (compare with what your agent produces; you do not type it by hand):
| ID | Rule | Citation | Side effects ||----|------|----------|--------------|| R-01 | Score starts at 2 | legacy/web/submit.asp:10; legacy/docs/desk-guide.ocr.txt:3 | none || R-02 | case_type is trimmed and upper-cased; "EMERGENCY" adds 4 | legacy/web/submit.asp:5; legacy/web/submit.asp:11; legacy/docs/desk-guide.ocr.txt:3 | none || R-03 | household_size >= 5 adds 1 | legacy/web/submit.asp:12; legacy/docs/desk-guide.ocr.txt:4 | none || R-04 | adds Round(days_waiting / 20) | legacy/web/submit.asp:13; legacy/docs/desk-guide.ocr.txt:4 | none || R-05 | score capped at 10 | legacy/web/submit.asp:14; legacy/docs/desk-guide.ocr.txt:6 | none || R-06 | status is FAST_TRACK when score >= 7, otherwise NEW | proc:usp_SubmitIntake | INSERT dbo.Intake || R-07 | every submission writes an audit row with action SUBMIT and the session user | proc:usp_SubmitIntake | INSERT dbo.IntakeAudit |unknowns.md is shorter and more useful to the next person: each entry names what is not known and who can say. U-01 (the 7-versus-8 conflict) is the one the office must answer before cutover; until it does, the new code reproduces the procedure, because the procedure is what applicants experience today.
The check script
Reading the agent’s file yourself works once. A script works every time the file changes. In gov-dev-reference-app, modernization/scripts/check-rules.sh verifies every citation automatically (ask your workspace agent to write a matching check for your folder):
REFERENCE CODE modernization/scripts/check-rules.sh: verify rule citations and reject seeded unsourced terms open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
#!/usr/bin/env bash# Usage: bash modernization/scripts/check-rules.sh [seeded-term ...]# Every row of rules.md must carry at least one citation, and every citation must resolve.# Each seeded term (a rule you told the agent but the source never states) must be# absent from rules.md and present in unknowns.md.set -ucd "$(dirname "$0")/.." || exit 1fail=0trim() { local s="$1"; s="${s#"${s%%[![:space:]]*}"}"; s="${s%"${s##*[![:space:]]}"}"; printf '%s' "$s"; }
while IFS='|' read -r _ id _ cite _; do id=$(trim "$id") [[ "$id" =~ ^R-[0-9]+$ ]] || continue IFS=';' read -ra parts <<< "$cite" if [ "${#parts[@]}" -eq 0 ]; then echo "FAIL $id: no citation"; fail=1; continue; fi for part in "${parts[@]}"; do part=$(trim "$part") case "$part" in proc:*) name=${part#proc:} grep -qE "CREATE PROCEDURE dbo\.${name}\b" legacy/sql/*.sql 2>/dev/null \ || { echo "FAIL $id: no procedure named $name"; fail=1; } ;; *:[0-9]*) file=${part%:*}; line=${part##*:} if [ ! -f "$file" ]; then echo "FAIL $id: $file does not exist"; fail=1 elif ! sed -n "${line}p" "$file" | grep -q '[^[:space:]]'; then echo "FAIL $id: $part is past the end of the file or blank"; fail=1 fi ;; *) echo "FAIL $id: '$part' is not file:line or proc:name"; fail=1 ;; esac donedone < rules.md
for term in "$@"; do if grep -qi "$term" rules.md; then echo "FAIL seeded rule '$term' is in rules.md"; fail=1; fi if ! grep -qi "$term" unknowns.md; then echo "FAIL seeded rule '$term' is missing from unknowns.md"; fail=1; fidone
[ "$fail" -eq 0 ] && echo "check-rules: ok"exit "$fail"It proves two things and no more. A citation resolves to a non-blank line or a procedure that exists; and a seeded term stays out of the rules file. It cannot tell whether the cited line says what the rule claims, so a reviewer still opens each citation. What the script removes is the cheapest way to be wrong: a line number that points nowhere.
Build the golden corpus
With rules.md in hand, record what the system actually does. The corpus is a list of inputs, each tagged with the rules it probes, and an expected.json of what the legacy system returned and wrote. No production code changes: you run a restored copy (a backup restored to a separate server, or a recorded copy a teammate already runs), post synthetic cases at it, and read the rows it wrote.
Ask your agent to generate the synthetic input cases from modernization/rules.md and modernization/unknowns.md:
Using modernization/rules.md and unknowns.md, generate synthetic test cases in modernization/golden/cases.json that cover every rule, boundary threshold, rounding tie, and input-normalization case. Use invented values only.Check that the generated cases.json covers every R-id in rules.md, places a case on each side of every threshold (scores 6, 7, and 8 for R-06 and U-01), tests the daysWaiting tie values 10, 30, and 50 for U-04, includes a padded lowercase caseType, and hits the score cap of 10.
Here is the reference ten-case corpus in modernization/golden/cases.json from gov-dev-reference-app (compare against what your agent generates; do not type this by hand):
[ { "id": "c01-routine-base", "input": { "caseType": "ROUTINE", "householdSize": 3, "daysWaiting": 0 }, "actor": "qa.caseworker", "exercises": ["R-01", "R-07"] }, { "id": "c02-emergency", "input": { "caseType": "EMERGENCY", "householdSize": 3, "daysWaiting": 0 }, "actor": "qa.caseworker", "exercises": ["R-02", "R-06"] }, { "id": "c03-household-five", "input": { "caseType": "ROUTINE", "householdSize": 5, "daysWaiting": 0 }, "actor": "qa.caseworker", "exercises": ["R-03"] }, { "id": "c04-wait-half-low", "input": { "caseType": "ROUTINE", "householdSize": 3, "daysWaiting": 10 }, "actor": "qa.caseworker", "exercises": ["R-04"] }, { "id": "c05-wait-one-and-half","input": { "caseType": "ROUTINE", "householdSize": 3, "daysWaiting": 30 }, "actor": "qa.caseworker", "exercises": ["R-04"] }, { "id": "c06-wait-two-and-half","input": { "caseType": "ROUTINE", "householdSize": 3, "daysWaiting": 50 }, "actor": "qa.caseworker", "exercises": ["R-04"] }, { "id": "c07-fast-track-at-7", "input": { "caseType": "EMERGENCY", "householdSize": 5, "daysWaiting": 0 }, "actor": "qa.caseworker", "exercises": ["R-06"] }, { "id": "c08-fast-track-at-8", "input": { "caseType": "EMERGENCY", "householdSize": 5, "daysWaiting": 20 }, "actor": "qa.caseworker", "exercises": ["R-06"] }, { "id": "c09-cap", "input": { "caseType": "EMERGENCY", "householdSize": 6, "daysWaiting": 200 }, "actor": "qa.caseworker", "exercises": ["R-05"] }, { "id": "c10-messy-case-type", "input": { "caseType": " emergency ", "householdSize": 3, "daysWaiting": 0 }, "actor": "qa.caseworker", "exercises": ["R-02"] }]Then record. This script runs against the restored copy only:
REFERENCE CODE modernization/scripts/record-golden.ts: record golden outputs and rows from a restored legacy copy open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
// Run against a RESTORED COPY of the legacy system, never production.import { readFileSync, writeFileSync } from 'node:fs';import sql from 'mssql';
const base = process.env.LEGACY_COPY_URL!; // origin of the restored copyconst pool = await sql.connect(process.env.LEGACY_COPY_DB!); // read access to its databaseconst out = process.argv[2] ?? 'modernization/golden/expected.json';const cases = JSON.parse(readFileSync('modernization/golden/cases.json', 'utf8'));const expected: Record<string, unknown> = {};
for (const c of cases) { const res = await fetch(`${base}/intake/submit.asp`, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded', cookie: process.env.LEGACY_COPY_COOKIE!, // a test caseworker's session on the copy }, body: new URLSearchParams({ case_type: c.input.caseType, household_size: String(c.input.householdSize), days_waiting: String(c.input.daysWaiting), }), }); // The page answers "CaseId|Status|score" as plain text (submit.asp:24). const [caseId, caseStatus, score] = (await res.text()).trim().split('|');
const intake = (await pool.request().input('id', sql.Int, Number(caseId)) .query(`SELECT CaseType, Score, Status, CONVERT(varchar(30), SubmittedAt, 121) AS SubmittedAt FROM dbo.Intake WHERE CaseId = @id`)).recordset[0]; const audit = (await pool.request().input('id', sql.Int, Number(caseId)) .query(`SELECT Action, Actor, CONVERT(varchar(30), At, 121) AS At FROM dbo.IntakeAudit WHERE CaseId = @id`)).recordset[0];
expected[c.id] = { response: { status: res.status, caseId: Number(caseId), caseStatus, score: Number(score) }, intake: { caseType: intake.CaseType, score: intake.Score, status: intake.Status, submittedAt: intake.SubmittedAt }, audit: { action: audit.Action, actor: audit.Actor, at: audit.At }, };}writeFileSync(out, JSON.stringify(expected, null, 2));await pool.close();Two things to do with the recording. First, read c04 and c06: if the recorded score for 10 days is 2 and for 50 days is 4, the runtime rounds a half to the even neighbour, and U-04 moves from unknowns.md into rules.md with the corpus case as its citation. If the copy says 3 and 5, it rounds half up, and the rule says that instead. You learn it by running the old system; you do not decide it. Second, record twice into different files. Any field that differs between two runs of the same input is either a tolerance you must document (the timestamp columns and the identity value will be the first two) or a flaw in the case, and lesson 23 supplies the comparison function.
Prove it
Run the check from a clean checkout. The seeded term is the rule you gave the agent that the source never states.
bash modernization/scripts/check-rules.sh veteranExpected on a good run:
check-rules: okNow plant each fault the script exists to catch, one at a time, and confirm each exits non-zero. Change a citation to a line that is not there (legacy/web/submit.asp:99) and check the output:
FAIL R-02: legacy/web/submit.asp:99 is past the end of the file or blankPaste the invented rule into rules.md as R-99 | Veterans add 1 | | and check the output:
FAIL R-99: '' is not file:line or proc:nameFAIL seeded rule 'veteran' is in rules.mdA second corpus check completes the proof. Every rule in rules.md must appear in at least one case’s exercises list, or the corpus does not cover it; lesson 23’s harness enforces that and prints the table.
You ask the agent for the intake rules and it returns a polished rules.md. Rule R-99, 'applications waiting more than 90 days are escalated to a supervisor', has no citation. What do you do?
The procedure promotes a case to FAST_TRACK at a score of 7. The desk guide says 8. Which goes in the new feature, and where does the conflict live?
Practice status — rule recovery from a legacy system before a rebuild
| Practice | Status | Also called |
|---|---|---|
| golden corpus recorded from the running legacy system | common baseline | characterization tests; golden master; approval tests |
| business rules written down with a source for each | strong optional | rule extraction; specification recovery; code archaeology |
| an unknowns list handed to the business owner | strong optional | open-questions log; assumptions register |
| AI-extracted rules gated by a citation check | emerging | grounded extraction; citation-or-unknown |
| recording from a restored copy, never production | common baseline | replay environment; recorded copy |
Scale: required | common baseline | strong optional | reference-shop (seen only at organizations that publish their own practice) | emerging
Key takeaway
An AI reading a legacy system will state rules the source never contained, so the output is split in two: rules.md holds only what carries a resolvable citation, unknowns.md holds everything else with who can settle it, and a short script enforces the line. The golden corpus then settles what source reading cannot, such as how the old runtime rounds a half, without a line of production code changing. The next lesson routes one intake route to the new feature and replays this corpus through both systems.
- LEADERSHIP DECISION
- the business owner answers the unknowns list (the 7-versus-8 fast-track conflict first) before the rebuilt feature is scheduled for cutover
- PRACTITIONER ACTION
- run the agent under citation-or-unknown, gate it with check-rules.sh, and record a golden corpus from a restored copy that covers every rule in rules.md
- SUCCESS MEASURE
- zero uncited rules in rules.md and every unknown owned by a named person - contract or revenue risk avoided by deciding before cutover, not discovering after
Legend: LEADERSHIP DECISION = what a leader decides · PRACTITIONER ACTION = what the engineer does next · SUCCESS MEASURE = how you know, in calendar time, assessor-hours or cost, contract or revenue risk, or audit finding avoided