Quote-template unification: eight supplier inputs, one cited brief

{
  "$schema": "https://unpkg.com/hankweave@0.10.0/schemas/hank.schema.json",
  "meta": {
    "name": "quote-template-unification",
    "version": "1.0.0",
    "description": "Normalize eight suppliers across three digitizer dialects and five native extracts against RFQ NC-RFQ-0042, quarantine GRN, reconcile 40 supplier-part rows, and publish a cited award brief plus exception queue."
  },
  "hank": [
    {
      "id": "normalize-aster",
      "name": "Normalize Aster (Datalab dialect)",
      "model": "haiku",
      "continuationMode": "fresh",
      "description": "Mechanical extraction of both Aster submissions (original + rev2) into canonical envelope objects. No judgment: dedup, alias resolution, and validity checks happen downstream.",
      "rigSetup": [
        {
          "type": "command",
          "command": {
            "run": "mkdir -p pipeline"
          }
        },
        {
          "type": "copy",
          "copy": {
            "from": "rigs/preflight.ts",
            "to": "pipeline/preflight.ts"
          }
        },
        {
          "type": "command",
          "command": {
            "run": "bun pipeline/preflight.ts"
          }
        }
      ],
      "promptFile": "prompts/normalize-aster.md",
      "checkpointedFiles": [
        "envelope-aster.json"
      ],
      "outputFiles": [
        {
          "copy": [
            "envelope-aster.json"
          ]
        }
      ],
      "onFailure": "abort",
      "budget": {
        "maxTimeSeconds": 240,
        "maxDollars": 0.5,

const REQUIRED_KEYS: Record<string, string[]> = {
  "digitized/aster.datalab-contract-fixture.json": ["document_id", "quote_meta", "fields", "lines"],
  "digitized/beacon.reducto-contract-fixture.json": ["document_id", "quote_meta", "result", "lines"],
  "digitized/cedar.generic-ocr-contract-fixture.json": ["document_id", "quote_meta", "ocr_blocks", "lines"],
  "digitized-extracts/aster-quote-qb-1047_rev2.json": ["document_id", "quote_meta", "lines"],
  "lookups/part-aliases.json": ["version", "aliases", "substitutions"],
  "lookups/unit-conversions.json": ["version", "conversions", "unknown_policy"],
  "lookups/fx-rates.json": ["version", "base", "rates"],
};

const NEEDS_WATERMARK = new Set([
  "digitized/aster.datalab-contract-fixture.json",
  "digitized/beacon.reducto-contract-fixture.json",
  "digitized/cedar.generic-ocr-contract-fixture.json",
  "digitized-extracts/aster-quote-qb-1047_rev2.json",
]);

type Finding = { path: string; ok: boolean; reason?: string };

function sha256(bytes: Buffer): string {
  return createHash("sha256").update(bytes).digest("hex");
}

function writeReportAndExit(ok: boolean, findings: Finding[]): never {
  writeFileSync(
    REPORT_PATH,
    JSON.stringify({ ok, checkedAt: new Date().toISOString(), dataRoot: DATA_ROOT, findings }, null, 2),
  );
  const failed = findings.filter((f) => !f.ok);

{
  "id": "quality-observer",
  "name": "Quality Observer",
  "description": "Observes the validate-and-repair completion event. Reports only status and budget fields present in that event; cannot read or verify output artifacts.",
  "trigger": {
    "type": "event",
    "on": [
      "codon.completed"
    ],
    "conditions": [
      {
        "operator": "equals",
        "path": "codonId",
        "value": "validate-and-repair"
      }
    ]
  },
  "execution": {
    "strategy": "immediate"
  },
  "model": "anthropic/claude-haiku-4-5",
  "userPromptText": "The codon `validate-and-repair` completed. Here are the triggering completion events:\n\n<%= JSON.stringify(it.events, null, 1) %>\n\nSummarize only status, failure reasons and budget fields actually present. These completion events do not provide file contents or file.updated events. State explicitly that artifact existence, row coverage and correctness cannot be verified from this input. Never treat missing file-update events as proof of missing files. Observe and report only.",
  "output": {
    "format": "text",
    "file": "quality-observer.log"
  }
}

      "id": "survey-and-extracts",
      "name": "Prepare native exports and review raw intake",
      "model": "haiku",
      "continuationMode": "fresh",
      "promptFile": "./prompts/survey-and-extracts.md",
      "rigSetup": [
        {
          "type": "copy",
          "copy": {
            "from": "rigs/native-inputs.ts",
            "to": "pipeline/native-inputs.ts"
          }
        },
        {
          "type": "command",
          "command": {
            "run": "bun pipeline/native-inputs.ts"
          }
        }
      ],
      "onFailure": "retry",
      "retryConfig": {
        "maxAttempts": 3,
        "delayMs": 20000,
        "maxDelayMs": 120000
      },
      "budget": {
        "maxDollars": 1.5,
        "maxTimeSeconds": 1800,
        "onExceeded": "complete"
      },
      "checkpointedFiles": [
        "envelope-dover.json",
        "envelope-embar.json",
        "envelope-fjord.json",
        "envelope-harbor.json",
        "envelope-iris.json",
        "survey-notes.json"
      ],
      "outputFiles": [
        {
          "copy": [
            "envelope-dover.json",
            "envelope-embar.json",
            "envelope-fjord.json",
            "envelope-harbor.json",
            "envelope-iris.json",
            "survey-notes.json"
          ]
        }
      ]
    },
    {
      "id": "validate-and-repair",
      "name": "Validate & Repair Envelopes",
      "model": "pi/baseten/deepseek-ai/DeepSeek-V4-Pro",
      "continuationMode": "fresh",
      "description": "Reads all eight supplier envelopes plus survey notes, the RFQ contract and lookups. Resolves aliases, substitutions, duplicate submissions and line extensions; quarantines GRN and routes unresolved hazards to the exception ledger.",
      "promptFile": "prompts/validate-and-repair.md",
      "rigSetup": [
        {
          "type": "copy",
          "copy": {
            "from": "rigs/native-inputs.ts",
            "to": "pipeline/native-inputs.ts"
          }
        },
        {
          "type": "command",
          "command": {
            "run": "bun pipeline/native-inputs.ts --check"
          }
        }
      ],
      "checkpointedFiles": [
        "validated-records.json",
        "exception-ledger.json"
      ],
      "outputFiles": [
        {
          "copy": [
            "validated-records.json",
            "exception-ledger.json"
          ]
        }
      ],
      "sentinels": [
        {
          "sentinelConfig": "sentinels/quality-observer.json"
        }
      ],
      "onFailure": "abort",
      "budget": {
        "maxDollars": 3.0,
        "maxTimeSeconds": 2400,
        "onExceeded": "complete"
      }
    },

      "id": "reconcile",
      "name": "Reconcile to Unified Records",
      "model": "pi/baseten/deepseek-ai/DeepSeek-V4-Pro",
      "continuationMode": "fresh",
      "description": "Joins validated records against the RFQ's 5-part BOM across all 8 quoting suppliers, guarantees exactly 40 data rows, and keeps GRN only in the exception ledger.",
      "promptFile": "prompts/reconcile.md",
      "checkpointedFiles": [
        "unified-records.csv",
        "exception-ledger.json"
      ],
      "outputFiles": [
        {
          "copy": [
            "unified-records.csv",
            "exception-ledger.json"
          ]
        }
      ],
      "onFailure": "abort",
      "budget": {
        "maxDollars": 2.0,
        "maxTimeSeconds": 1800,
        "onExceeded": "fail"
      }
    },
    {
      "id": "award-brief",
      "name": "Award Brief & Exception Queue",
      "model": "haiku",
      "continuationMode": "fresh",
      "description": "Renders cited financial recommendations deterministically from reconciled rows; the agent completes only a qualitative assessment. Source-based pre-copy checks protect the financial block and the lossless exception CSV.",
      "promptFile": "prompts/award-brief.md",
      "rigSetup": [
        {
          "type": "copy",
          "copy": {
            "from": "rigs/render-exceptions.ts",
            "to": "pipeline/render-exceptions.ts"
          }
        },
        {
          "type": "copy",
          "copy": {
            "from": "rigs/render-award.ts",
            "to": "pipeline/render-award.ts"
          }
        },
        {
          "type": "command",
          "command": {
            "run": "bun pipeline/render-exceptions.ts && bun pipeline/render-award.ts"
          }
        }
      ],
      "checkpointedFiles": [
        "award-brief.md",
        "exceptions.csv"
      ],
      "outputFiles": [
        {
          "beforeCopy": [
            {
              "type": "command",
              "command": {
                "run": "bun pipeline/render-exceptions.ts --check && bun pipeline/render-award.ts --check"
              }
            }
          ],
          "copy": [
            "award-brief.md",
            "exceptions.csv",
            "unified-records.csv"
          ]
        }
      ],
      "onFailure": "abort",
      "budget": {
        "maxDollars": 1.0,
        "maxTimeSeconds": 1200,
        "onExceeded": "complete"
      }
    }
  ]
}

  const surveyed = fs.readdirSync(path.join(root, 'source-quotes')).filter((name) => fs.statSync(path.join(root, 'source-quotes', name)).isFile()).sort().map((name) => `source-quotes/${name}`);
  const recognizedFiles = new Set(recognized.map((item) => item.file));
  const unmatched = surveyed.filter((file) => !recognizedFiles.has(file));
  const surveyFile = path.join(output, 'survey-notes.json');
  if (!check) {
    fs.writeFileSync(surveyFile, JSON.stringify({ complete: false, surveyed, recognized, unmatched, quarantined: [] }, null, 2) + '\n');
  } else {
    const survey = JSON.parse(fs.readFileSync(surveyFile, 'utf8'));
    require(survey.complete === true, 'Intake survey is incomplete');
    require(JSON.stringify(survey.surveyed) === JSON.stringify(surveyed), 'Generated surveyed-file list changed');
    require(JSON.stringify(survey.unmatched) === JSON.stringify(unmatched), 'Generated unmatched-file list changed');
    require(Array.isArray(survey.recognized) && JSON.stringify(survey.recognized.map((item: Row) => [item.file, item.document_id, item.evidence])) === JSON.stringify(recognized.map((item) => [item.file, item.document_id, item.evidence])), 'Generated source-file recognition changed');
    require(Array.isArray(survey.quarantined), 'Survey is missing the quarantine array');
    const accounted = new Set<string>();
    for (const item of survey.quarantined) {
      const file = text(item.file, 'quarantined file').replace(/^read_only_data_source\//, '');
      require(unmatched.includes(file) && !accounted.has(file), `${file}: not an unmatched intake file, or listed twice`);
      text(item.supplier_hint, `${file}: supplier hint`); text(item.reason, `${file}: quarantine reason`);
      accounted.add(file);
    }
    require(accounted.size === unmatched.length, 'An unmatched intake file was not reviewed');
  }
  console.log(`Native inputs: ${names.length} envelopes, ${names.reduce((sum, name) => sum + outputs[name].lines.length, 0)} lines; ${unmatched.length} unmatched intake file(s); ${check ? 'completed survey verified' : 'survey awaits agent review'}.`);

const columns = ['exception_id', 'type', 'supplier_code', 'buyer_part_id', 'detail', 'resolution', 'source_ref'] as const;

function cell(value: unknown): string {
  if (value === null || value === undefined) return '';
  if (!['string', 'number', 'boolean'].includes(typeof value)) throw new Error('Exception CSV fields must be scalar values');
  const text = String(value);
  return /[",\r\n]/.test(text) ? '"' + text.replace(/"/g, '""') + '"' : text;
}

try {
  const ledger = JSON.parse(fs.readFileSync(path.join(workspace, 'exception-ledger.json'), 'utf8'));
  if (!Array.isArray(ledger)) throw new Error('Exception ledger must be an array');
  const ids = new Set<string>();
  for (const row of ledger) {
    if (!row || typeof row !== 'object' || columns.some(column => !(column in row))) throw new Error('Exception ledger row is missing required fields');
    if (typeof row.exception_id !== 'string' || !row.exception_id || ids.has(row.exception_id)) throw new Error('Exception IDs must be present and unique');
    ids.add(row.exception_id);
  }
  const order = new Intl.Collator('en', { numeric: true });
  ledger.sort((a, b) => order.compare(a.exception_id, b.exception_id));
  const rendered = [columns.join(','), ...ledger.map(row => columns.map(column => cell(row[column])).join(','))].join('\n') + '\n';
  const target = path.join(workspace, 'exceptions.csv');
  if (check) {
    if (fs.readFileSync(target, 'utf8') !== rendered) throw new Error('Exception CSV differs from its ledger; rerun the renderer');

function amount(value: string, row: Row): string {
  const minor = integer(value, 'Price');
  const whole = (minor / 100n).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  return `$${whole}.${(minor % 100n).toString().padStart(2, '0')} ${citation(row)}`;
}
function records(text: string): Row[] {
  const [header, ...data] = csv(text);
  require(header?.join(',') === columns.join(','), 'Unified CSV header differs from the reconciled row contract');
  require(data.length === suppliers.length * parts.length, 'Expected exactly 40 supplier-part rows');
  const keys = new Set<string>(), quantities = new Map<string, string>();
  return data.map(cells => {
    require(cells.length === columns.length, 'Malformed unified CSV row');
    const row = Object.fromEntries(columns.map((name, i) => [name, cells[i]]));
    const key = `${row.supplier_code}/${row.buyer_part_id}`;
    require(suppliers.includes(row.supplier_code) && parts.includes(row.buyer_part_id) && !keys.has(key), `Unknown or duplicate supplier-part row: ${key}`);
    keys.add(key);
    require(row.rfq_rev === 'B', `Unsupported RFQ revision: ${key}`);
    require(integer(row.qty, `Quantity for ${key}`) > 0n, `Quantity must be positive: ${key}`);
    require(!quantities.has(row.buyer_part_id) || quantities.get(row.buyer_part_id) === row.qty, `Cannot compare different ordered quantities: ${key}`);
    quantities.set(row.buyer_part_id, row.qty);
    require(['QUOTED', 'NO_BID', 'UNRESOLVED', 'QUARANTINED'].includes(row.status), `Unsupported status: ${key}`);
    require(['true', 'false'].includes(row.ranking_eligible), `Invalid ranking eligibility: ${key}`);
    if (row.status === 'QUOTED') {
      require(row.currency === 'USD', `Cannot render an unsupported or missing currency as dollars: ${key}`);
      require(['PER_EACH', 'PACK', 'BOX'].includes(row.price_basis), `Unsupported normalized price basis: ${key}`);
      const unit = integer(row.unit_price_minor, `Unit price for ${key}`);
      const extension = integer(row.line_extension_minor, `Line extension for ${key}`);
      require(unit * BigInt(row.qty) === extension, `Unit price and line extension disagree: ${key}`);
      citation(row);
    } else {
      require(row.ranking_eligible === 'false', `A non-QUOTED row cannot be eligible: ${key}`);
      require(row.unit_price_minor === '' && row.line_extension_minor === '', `Non-QUOTED prices must remain blank: ${key}`);

function financials(rows: Row[]): string {
  const lines = [
    '# Award brief', '', '<!-- BEGIN GENERATED FINANCIALS -->', '## Financial recommendation', '',
    'Projection of unified-records.csv only. Rank QUOTED, ranking_eligible=true rows by line_extension_minor; break equal-price ties by supplier_code ascending. Unit prices are already normalized per each upstream. No eligible bid means no recommendation; unsupported data stops export rather than inventing a price or citation.', '',
    '| Buyer part | Selected supplier | Unit price (USD per each) | Line extension (USD) | Tie / no-bid decision | Ineligible QUOTED suppliers |',
    '| --- | --- | --- | --- | --- | --- |',
  ];
  for (const part of parts) {
    const partRows = rows.filter(row => row.buyer_part_id === part);
    const eligible = partRows.filter(row => row.status === 'QUOTED' && row.ranking_eligible === 'true');
    eligible.sort((a, b) => {
      const left = BigInt(a.line_extension_minor), right = BigInt(b.line_extension_minor);
      return left < right ? -1 : left > right ? 1 : a.supplier_code < b.supplier_code ? -1 : a.supplier_code > b.supplier_code ? 1 : 0;
    });
    const winner = eligible[0];
    const excluded = partRows.filter(row => row.status === 'QUOTED' && row.ranking_eligible === 'false')
      .sort((a, b) => a.supplier_code < b.supplier_code ? -1 : 1)
      .map(row => `${row.supplier_code} ${citation(row)}`).join('; ') || 'None';
    if (!winner) lines.push(`| ${part} | No eligible QUOTED bid | — | — | No recommendation | ${excluded} |`);
    else {
      const tied = eligible.filter(row => row.line_extension_minor === winner.line_extension_minor).map(row => row.supplier_code);
      const decision = tied.length > 1 ? `Tie: ${tied.join(', ')}; supplier_code order selects ${winner.supplier_code}` : 'Unique lowest eligible bid';
      lines.push(`| ${part} | ${winner.supplier_code} | ${amount(winner.unit_price_minor, winner)} | ${amount(winner.line_extension_minor, winner)} | ${decision} | ${excluded} |`);
    }
  }
  return lines.join('\n') + '\n<!-- END GENERATED FINANCIALS -->\n';

{
  "runtime": "0.10.0",
  "captured_at": "2026-09-06T13:07:23.154353+00:00",
  "scope": "one complete live execution",
  "tracked_codons_cost": 0.8830336700000001,
  "models": {
    "normalize-aster": "haiku",
    "normalize-beacon": "haiku",
    "normalize-cedar": "haiku",
    "survey-and-extracts": "haiku",
    "validate-and-repair": "pi/baseten/deepseek-ai/DeepSeek-V4-Pro",
    "reconcile": "pi/baseten/deepseek-ai/DeepSeek-V4-Pro",
    "award-brief": "haiku"
  },
  "codons": [
    {
      "codonId": "normalize-aster",