domain-spec-fix

README.md

@@ -88,6 +88,26 @@ print(ds)
 print(ds["train"][0].keys())
 ```
 
+## Expose Workflow Labels (Inferred)
+The public `tasks_and_rubrics.json` currently does not include per-task `workflow` labels, even though the paper describes workflow metadata.
+
+This repo includes a helper script to expose inferred workflow labels for all three domains (Investment Banking, Management Consulting, Law):
+
+```bash
+python3 scripts/expose_workflows.py
+```
+
+Outputs:
+- `tasks_and_rubrics_with_workflow.json` (original tasks plus inferred `workflow`)
+- `workflow_inference_audit.csv` (task-level confidence/rank/signals for manual QA)
+
+Method summary:
+- Uses prompt/rubric/gold-response/file-name signals to score workflows per domain.
+- Applies quota-constrained assignment so each domain’s workflow counts match Table 6 in the APEX–Agents paper.
+
+Important:
+- These are **inferred labels**, not official ground-truth workflow annotations from Mercor.
+
 ## Citation
 
 ```bibtex
@@ -120,4 +140,4 @@ Disallow: /
 We ask that:
 • You do *not* crawl, scrape, index, or download this dataset programmatically.
 • You do *not* use this dataset for training models or any automated processing
-  without express permission from the dataset owner.
+  without express permission from the dataset owner.

scripts/expose_workflows.py

@@ -0,0 +1,586 @@
+#!/usr/bin/env python3
+"""Expose inferred workflow labels for APEX-Agents tasks.
+
+The public `tasks_and_rubrics.json` includes `domain` metadata but omits
+workflow/sub-task labels. This script infers per-domain workflows from task
+text and task file names, then applies quota-constrained assignment so each
+domain matches the workflow distribution reported in Table 6 of the paper.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import DefaultDict
+
+import numpy as np
+from scipy.optimize import linear_sum_assignment
+
+
+DOMAIN_WORKFLOW_QUOTAS = {
+    "Investment Banking": {
+        "Comparables": 16,
+        "DCF": 42,
+        "Debt Model": 6,
+        "LBO": 12,
+        "Market / Sector Research": 3,
+        "Merger Model": 7,
+        "Sensitivity Analysis": 46,
+        "Valuation Analysis": 28,
+    },
+    "Management Consulting": {
+        "Benchmarking / Competitive Analysis": 26,
+        "Cost Benefit Analysis": 11,
+        "Market Sizing, TAM, SAM": 14,
+        "Operations Analysis": 23,
+        "Scenario/Sensitivity Analysis": 35,
+        "Strategy Recommendations": 5,
+        "Survey / Interview Analysis": 31,
+        "Variance / Performance Analysis": 15,
+    },
+    "Law": {
+        "Compliance Program Review": 16,
+        "Contract Review": 30,
+        "Due Diligence": 18,
+        "Internal Investigations": 3,
+        "Legal Research": 47,
+        "Litigation Strategy": 8,
+        "Motion Drafting": 6,
+        "Risk Assessment": 24,
+        "Other": 8,
+    },
+}
+
+
+DOMAIN_BASE_PRIORS = {
+    "Investment Banking": {
+        "Comparables": 0.12,
+        "DCF": 0.25,
+        "Debt Model": 0.05,
+        "LBO": 0.12,
+        "Market / Sector Research": 0.05,
+        "Merger Model": 0.07,
+        "Sensitivity Analysis": 0.22,
+        "Valuation Analysis": 0.18,
+    },
+    "Management Consulting": {
+        "Benchmarking / Competitive Analysis": 0.18,
+        "Cost Benefit Analysis": 0.08,
+        "Market Sizing, TAM, SAM": 0.12,
+        "Operations Analysis": 0.16,
+        "Scenario/Sensitivity Analysis": 0.2,
+        "Strategy Recommendations": 0.06,
+        "Survey / Interview Analysis": 0.15,
+        "Variance / Performance Analysis": 0.12,
+    },
+    "Law": {
+        "Compliance Program Review": 0.1,
+        "Contract Review": 0.2,
+        "Due Diligence": 0.1,
+        "Internal Investigations": 0.1,
+        "Legal Research": 0.2,
+        "Litigation Strategy": 0.1,
+        "Motion Drafting": 0.1,
+        "Risk Assessment": 0.2,
+        "Other": 0.1,
+    },
+}
+
+
+# (signal_name, regex, weight)
+DOMAIN_SIGNALS = {
+    "Investment Banking": {
+        "Comparables": [
+            ("comparables_term", r"\bcomparables?\b|\bcomps?\b|\bpublic comparables?\b", 4.2),
+            ("precedent_transactions", r"\bprecedent transactions?\b|\bprecedents?\b", 3.2),
+            ("peer_group", r"\bpeer group\b|\bpeer set\b|\bpeer analysis\b", 2.6),
+            ("multiple_focus", r"\bev/?ebitda\b|\bev/?ebit\b|\bp/?e\b|\bev/?fcf\b|\btrading multiples?\b", 1.8),
+        ],
+        "DCF": [
+            ("dcf_term", r"\bdcf\b|\bdiscounted cash flow\b", 4.6),
+            ("wacc_terminal", r"\bwacc\b|\bterminal value\b|\bterminal growth\b|\bperpetuity\b", 2.7),
+            ("discount_build", r"\bcost of equity\b|\brisk[- ]free rate\b|\bbeta\b|\bequity risk premium\b", 2.3),
+            ("discounted_fcf", r"\bdiscounted free cash flow\b|\b(un)?levered free cash flow\b|\bpv of free cash flows?\b", 2.2),
+        ],
+        "Debt Model": [
+            ("debt_model_term", r"\bdebt model\b|\bdebt schedule\b", 4.8),
+            ("debt_instruments", r"\brevolver\b|\bterm loan\b|\bdebenture\b|\bcoupon\b|\bamortization\b|\bprincipal\b", 3.0),
+            ("debt_metrics", r"\binterest coverage\b|\bleverage ratio\b|\bnet debt\b|\bdebt capacity\b", 2.4),
+        ],
+        "LBO": [
+            ("lbo_term", r"\blbo\b|\bleveraged buyout\b", 4.8),
+            ("returns_terms", r"\birr\b|\bmoic\b|\bsponsor equity\b", 3.5),
+            ("entry_exit_terms", r"\bentry multiple\b|\bexit multiple\b|\bpremium paid\b|\bability to pay\b", 2.2),
+        ],
+        "Market / Sector Research": [
+            ("market_sector_research_term", r"\bmarket (?:or )?sector research\b|\bsector research\b", 4.2),
+            ("industry_outlook", r"\bindustry outlook\b|\bsector outlook\b|\bmarket outlook\b", 3.1),
+            ("addressable_market", r"\baddressable market\b|\btam\b|\bsam\b", 2.0),
+        ],
+        "Merger Model": [
+            ("merger_model_term", r"\bmerger model\b|\baccretion dilution model\b", 4.5),
+            ("accretion_dilution", r"\baccretion\b|\bdilution\b", 3.6),
+            ("proforma_exchange", r"\bpro[\s-]?forma\b|\bexchange ratio\b|\bcombined company\b", 3.0),
+            ("consideration_mix", r"\bcash consideration\b|\bstock consideration\b|\bstock portion\b", 2.1),
+        ],
+        "Sensitivity Analysis": [
+            ("sensitivity_term", r"\bsensitivity\b|\bscenario\b", 3.4),
+            ("scenario_cases", r"\bupside\b|\bdownside\b|\blow case\b|\bmid case\b|\bhigh case\b", 2.7),
+            ("shock_flex", r"\bshock\b|\bstep-?up\b|\bstep-?down\b|\bflex(?:ing)?\b|\bcritical point\b", 2.6),
+            ("assumption_change", r"\bassuming\b|\badjust\b|\bwhat if\b", 1.4),
+        ],
+        "Valuation Analysis": [
+            ("valuation_term", r"\bvaluation\b|\bfair value\b", 2.9),
+            ("implied_value", r"\bimplied share price\b|\benterprise value\b|\bprice per share\b|\boffer price\b", 2.6),
+            ("premium_discount", r"\bpremium\b|\bdiscount\b|\bimplied upside/downside\b", 2.0),
+            ("npv_present_value", r"\bnpv\b|\bnet present value\b|\bpresent value\b", 1.8),
+        ],
+    },
+    "Management Consulting": {
+        "Benchmarking / Competitive Analysis": [
+            ("benchmarking_term", r"\bbenchmark(?:ing)?\b", 3.7),
+            ("competitive_term", r"\bcompetitive\b|\bcompetitor(?:s)?\b|\bpeer(?:s)?\b|\blandscape\b", 3.0),
+            ("ranking_compare", r"\brank(?:ing)?\b|\bcompare\b|\bversus\b|\bagainst\b", 1.9),
+            ("market_share_compare", r"\bmarket share\b", 1.7),
+        ],
+        "Cost Benefit Analysis": [
+            ("cost_benefit_term", r"\bcost[- ]benefit\b|\bcost benefit\b", 4.8),
+            ("payback_roi", r"\bpayback period\b|\broi\b", 3.3),
+            ("npv_term", r"\bnpv\b|\bnet present value\b", 3.1),
+            ("savings_investment", r"\btotal savings\b|\bone-time investment\b|\bannual benefit\b|\bprofit opportunity\b", 2.2),
+        ],
+        "Market Sizing, TAM, SAM": [
+            ("market_sizing_term", r"\bmarket sizing\b|\bmarket size\b", 4.1),
+            ("tam_sam_som", r"\btam\b|\bsam\b|\bsom\b|\baddressable market\b", 4.6),
+            ("implied_share_size", r"\bimplied market share\b|\btotal market size\b", 2.2),
+        ],
+        "Operations Analysis": [
+            ("operations_term", r"\boperations?\b|\boperational\b|\bproductivity\b|\bworkforce\b|\bstaffing\b|\bheadcount\b", 2.8),
+            ("plant_asset_maintenance", r"\bplant\b|\bequipment\b|\bmaintenance\b|\bdowntime\b|\bscrap\b|\byield\b|\basset\b", 2.5),
+            ("throughput_capacity", r"\bcapacity\b|\butilization\b|\bthroughput\b|\bspan of control\b", 2.0),
+            ("regression_term", r"\bregression\b|\bcorrelated\b", 1.8),
+        ],
+        "Scenario/Sensitivity Analysis": [
+            ("scenario_term", r"\bscenario\b|\bsensitivity\b", 3.8),
+            ("case_terms", r"\blow case\b|\bmid case\b|\bhigh case\b|\bstress case\b", 2.8),
+            ("assumption_shifts", r"\bassuming\b|\bwhat if\b|\badjust(?:ed|ment)\b|\bchange in\b", 1.5),
+            ("if_then", r"\bif\b.{0,35}\bthen\b", 1.6),
+        ],
+        "Strategy Recommendations": [
+            ("recommend_term", r"\brecommend(?:ation|ed)?\b|\bshould proceed\b|\bgo/no-go\b", 4.8),
+            ("strategic_option", r"\bstrategic option\b|\brecommended path\b|\bdecision score\b", 2.8),
+        ],
+        "Survey / Interview Analysis": [
+            ("survey_term", r"\bsurvey\b|\bquestionnaire\b|\brespondents?\b|\bresponse dataset\b", 4.0),
+            ("interview_term", r"\binterview\b|\bcall summary\b|\bcohort\b|\bsentiment\b", 3.0),
+            ("satisfaction_intent", r"\bsatisfaction\b|\bintent\b|\bpreferences?\b", 1.7),
+        ],
+        "Variance / Performance Analysis": [
+            ("variance_term", r"\bvariance\b|\bperformance analysis\b", 4.2),
+            ("gap_delta", r"\bgap\b|\bdelta\b|\bdifference\b|\bvs\.?\b|\brelative to\b", 2.4),
+            ("target_attainment", r"\btarget\b|\bover[- ]?perform\b|\bunder[- ]?perform\b|\battainment\b", 2.2),
+            ("pp_change", r"\bpercentage points?\b|\b% change\b", 2.0),
+        ],
+    },
+    "Law": {
+        "Compliance Program Review": [
+            ("compliance_review", r"\bcompliance review\b", 4.0),
+            ("compliance_program", r"\bcompliance program\b", 3.0),
+            ("policy_or_procedure", r"\bpolic(?:y|ies)\b|\bprocedures?\b|\bprotocols?\b", 1.9),
+            ("regulatory_compliance", r"\bregulatory compliance\b|\bin compliance with\b", 2.0),
+            ("framework_or_controls", r"\bframework\b|\bcontrols?\b", 1.6),
+            ("audit_or_supervision", r"\baudit\b|\bmra\b|\bcfpb\b|\bsupervision and examination\b", 1.8),
+            ("notice_obligation", r"\bnotification requirements?\b|\bbreach and incident response policy\b", 1.4),
+            ("sec_disclosure_controls", r"\b8-k\b|\bform 8-k\b|\bsec\b|\breg fd\b|\brule 10b-5\b", 2.1),
+            ("facility_fire_safety", r"\bfire safety\b|\binspection report\b|\bexit signage\b", 1.7),
+        ],
+        "Contract Review": [
+            ("agreement_or_contract", r"\bagreement\b|\bcontract\b|\bclause\b|\bterms?\b", 1.5),
+            ("specific_agreement_type", r"\bmaster supply agreement\b|\bmsa\b|\blease\b|\boperating agreement\b|\bcharter party\b|\bjv agreement\b", 2.3),
+            ("force_majeure", r"\bforce majeure\b", 2.8),
+            ("execution_or_amendment", r"\bexecuted\b|\bamend(?:ed|ment)\b|\brevise\b|\bredline\b", 1.3),
+            ("validity_or_notice", r"\bvalid\b.{0,35}\bnotice\b|\bcommencement date\b", 1.6),
+            ("section_by_section", r"\barticles?\b\s+\d|\bsection[s]?\b\s+\d", 1.2),
+        ],
+        "Due Diligence": [
+            ("due_diligence_phrase", r"\bdue diligence\b|\bdiligence file\b|\bdiligence memo\b", 4.8),
+            ("transaction_context", r"\bacquisition\b|\btransaction\b|\bpurchaser\b|\bseller\b|\bpost-?closing\b|\bpre-?closing\b", 2.4),
+            ("deal_docs", r"\bshare purchase agreement\b|\bstock purchase agreement\b|\bspa\b|\bindemnities?\b|\brepresentations?\b", 2.0),
+            ("diligence_review", r"\breview\b.{0,35}\bdiligence\b|\bdiligence\b.{0,35}\breview\b", 2.5),
+            ("closing_checklist", r"\bclosing checklist\b|\bchecklist\b", 1.4),
+            ("regulatory_deal_filing", r"\bhsr\b|\bfiling submission\b|\bpremerger\b", 1.8),
+        ],
+        "Internal Investigations": [
+            ("internal_investigation", r"\binternal investigation\b|\bincident investigation\b|\boutage investigation\b", 4.6),
+            ("incident_postmortem", r"\bincident report\b|\bpostmortem\b|\broot cause\b|\btimeline\b|\bevent logs?\b", 3.4),
+            ("email_chain", r"\bemail chain\b|\bemail exchange\b", 2.2),
+            ("outage_findings", r"\boutage\b.{0,35}\binvestigation\b|\bindependent investigation\b", 2.4),
+            ("forensic_review", r"\bforensic\b|\binterrogatories\b|\bcivil investigative demand\b", 1.6),
+        ],
+        "Legal Research": [
+            ("law_or_statute_question", r"\bunder\b.{0,45}\b(?:law|code|act|rule|regulation|statute)\b", 2.1),
+            ("citation_request", r"\bcite\b|\brelevant section\b|\bwhat (?:does|is)\b|\bwhich section\b", 1.7),
+            ("authority_tokens", r"\b\d+\s*u\.?s\.?c\.?\b|\b\d+\s*c\.?f\.?r\.?\b|\bfrcp\b|\bgdpr\b|\barticle \d+\b|\bncac\b|\bplanning act\b", 2.3),
+            ("cases_and_courts", r"\bcase law\b|\bcourt\b|\bprecedent\b|\bholding\b|\bopinion\b", 1.9),
+            ("requirements_question", r"\bdoes\b.{0,40}\brequire\b|\bis .* legal\b", 1.4),
+        ],
+        "Litigation Strategy": [
+            ("likelihood_success", r"\blikelihood of success\b|\bchance of success\b|\bsurviv(?:e|ing)\b.{0,40}\bsummary judgment\b", 4.2),
+            ("claims_defenses", r"\bclaims?\b|\bdefenses?\b|\bcounterclaims?\b|\bstrongest argument\b", 2.3),
+            ("forum_and_venue", r"\bvenue\b|\bjurisdiction\b|\barbitration\b|\bpre-?trial\b|\bsettlement\b", 1.9),
+            ("dismissal_strategy", r"\bmotion to dismiss\b|\brule 12\b|\bstrategy\b", 1.9),
+        ],
+        "Motion Drafting": [
+            ("draft_motion_material", r"\bdraft\b.{0,55}\b(?:motion|complaint|brief|memorandum|memo|outline)\b", 4.4),
+            ("prepare_motion_material", r"\bprepare\b.{0,55}\b(?:motion|brief|memorandum|outline)\b", 3.9),
+            ("new_doc_litigation", r"\bpre-?litigation legal memorandum\b|\bsummary judgment\b", 2.7),
+            ("edit_litigation_doc", r"\bedit existing\b.{0,35}\b(?:agreement|complaint|motion)\b", 1.8),
+        ],
+        "Risk Assessment": [
+            ("risk_or_exposure", r"\brisk\b|\bexposure\b|\bfinancial exposure\b", 2.0),
+            ("liability_penalty", r"\bliability\b|\bfine\b|\bpenalty\b|\bdamages?\b|\brefund\b", 1.8),
+            ("max_amount", r"\bmaximum\b.{0,35}\b(?:liability|fine|penalty|refund|exposure)\b", 2.4),
+            ("amount_question", r"\bhow much\b|\bwhat amount\b|\bpotential\b", 1.2),
+            ("risk_matrix", r"\bheat map\b|\bmitigation\b", 1.6),
+            ("defect_or_fault", r"\bfaulty\b|\bdefect(?:ive)?\b|\boutage\b", 1.2),
+        ],
+        "Other": [
+            ("spreadsheet_output", r"\bmake_new_sheet\b|\bedit_existing_sheet\b", 4.8),
+            ("capital_account", r"\bcapital account\b|\bdistribution amounts?\b", 2.6),
+            ("child_support_calc", r"\bchild support\b", 2.8),
+            ("quant_membership", r"\bpart of the class\b|\bhistoric stock transactions\b|\bmaximum refund amount\b", 2.4),
+            ("distribution_calc", r"\bdetermine\b.{0,35}\bamounts? to be distributed\b", 2.6),
+        ],
+    },
+}
+
+
+def _build_task_file_index(task_files_root: Path) -> dict[str, str]:
+    """Build task_id -> concatenated file-name hint string."""
+    index: dict[str, str] = {}
+    if not task_files_root.exists():
+        return index
+
+    for task_dir in sorted(task_files_root.glob("task_*")):
+        if not task_dir.is_dir():
+            continue
+        file_tokens: list[str] = []
+        for path in task_dir.rglob("*"):
+            if path.is_file():
+                file_tokens.append(path.relative_to(task_dir).as_posix())
+        index[task_dir.name] = "\n".join(file_tokens)
+    return index
+
+
+def _task_text(task: dict, task_file_hints: str) -> str:
+    rubric_text = "\n".join(item.get("criteria", "") for item in task.get("rubric", []))
+    parts = [
+        task.get("prompt", ""),
+        rubric_text,
+        task.get("gold_response", ""),
+        task.get("expected_output", ""),
+        task_file_hints,
+    ]
+    return "\n".join(parts)
+
+
+def _score_task(task: dict, task_file_hints: str) -> tuple[dict[str, float], dict[str, list[str]]]:
+    domain = task.get("domain")
+    if domain not in DOMAIN_WORKFLOW_QUOTAS:
+        return {}, {}
+
+    workflows = list(DOMAIN_WORKFLOW_QUOTAS[domain].keys())
+    priors = DOMAIN_BASE_PRIORS[domain]
+    signals = DOMAIN_SIGNALS[domain]
+
+    text = _task_text(task, task_file_hints).lower()
+    scores: dict[str, float] = {workflow: priors.get(workflow, 0.0) for workflow in workflows}
+    reasons: DefaultDict[str, list[str]] = defaultdict(list)
+
+    def add(workflow: str, amount: float, reason: str) -> None:
+        scores[workflow] += amount
+        reasons[workflow].append(f"{reason} (+{amount:.1f})")
+
+    for workflow, rules in signals.items():
+        for name, pattern, weight in rules:
+            if re.search(pattern, text, flags=re.IGNORECASE):
+                add(workflow, weight, name)
+
+    expected_output = task.get("expected_output", "")
+
+    if domain == "Investment Banking":
+        if expected_output in {"make_new_sheet", "edit_existing_sheet"}:
+            add("Sensitivity Analysis", 2.4, "sheet_output_sensitivity")
+        if expected_output == "make_new_slide_deck":
+            add("Valuation Analysis", 1.3, "slide_output_valuation")
+
+        if re.search(r"\blbo\b", text) and re.search(r"\bscenario\b|\bsensitivity\b|\bshock\b|\bflex\b", text):
+            add("Sensitivity Analysis", 1.5, "lbo_with_sensitivity")
+        if re.search(r"\bdcf\b", text) and re.search(r"\bscenario\b|\bsensitivity\b|\bassum", text):
+            add("Sensitivity Analysis", 1.2, "dcf_with_sensitivity")
+        if re.search(r"\baccretion dilution model\b|\bmerger model\b", text):
+            add("Merger Model", 2.0, "explicit_merger_model")
+        if re.search(r"\bprecedent\b|\bpublic comparables?\b", text) and re.search(r"\bmultiple\b", text):
+            add("Comparables", 1.4, "comparables_with_multiples")
+        if re.search(r"\bimplied share price\b|\benterprise value\b", text) and not re.search(
+            r"\blbo\b|\bmerger model\b", text
+        ):
+            add("Valuation Analysis", 1.2, "implied_value_focus")
+        if re.search(r"\bdebt\b", text) and re.search(r"\bterm loan\b|\brevolver\b|\binterest coverage\b", text):
+            add("Debt Model", 1.6, "debt_instrument_focus")
+
+    if domain == "Management Consulting":
+        if expected_output in {"make_new_slide_deck", "edit_existing_slide_deck"}:
+            add("Benchmarking / Competitive Analysis", 0.9, "slide_output_benchmarking")
+        if expected_output == "make_new_doc":
+            add("Strategy Recommendations", 1.0, "doc_output_strategy")
+
+        if re.search(r"\bsurvey\b", text) and re.search(r"\brecommend", text):
+            add("Strategy Recommendations", 1.1, "survey_with_recommendation")
+        if re.search(r"\bpayback period\b|\bone-time investment\b|\bannual savings\b", text):
+            add("Cost Benefit Analysis", 2.2, "payback_investment_focus")
+        if re.search(r"\bregression\b|\bcorrelat", text):
+            add("Operations Analysis", 1.6, "regression_operations_focus")
+        if re.search(r"\bgap\b|\bdelta\b|\bversus target\b|\brelative to\b", text):
+            add("Variance / Performance Analysis", 1.3, "gap_vs_target")
+        if re.search(r"\bscenario\b", text) and re.search(r"\bassum", text):
+            add("Scenario/Sensitivity Analysis", 1.4, "scenario_with_assumptions")
+        if re.search(r"\btam\b|\bsam\b|\bsom\b", text):
+            add("Market Sizing, TAM, SAM", 1.7, "tam_sam_som_bonus")
+
+    if domain == "Law":
+        if expected_output in {"make_new_doc", "edit_existing_doc"}:
+            if re.search(r"\bmotion\b|\bcomplaint\b|\bbrief\b|\bsummary judgment\b", text):
+                add("Motion Drafting", 2.0, "doc_output_with_litigation_terms")
+            elif re.search(r"\bagreement\b|\bcontract\b|\blease\b|\bmsa\b", text):
+                add("Contract Review", 1.3, "doc_output_with_contract_terms")
+            else:
+                add("Motion Drafting", 0.8, "doc_output_default")
+
+        if expected_output in {"make_new_sheet", "edit_existing_sheet"}:
+            add("Other", 5.0, "sheet_output")
+
+        if re.search(r"\bclass action\b|\bmotion to dismiss\b|\bsummary judgment\b", text):
+            add("Litigation Strategy", 1.2, "litigation_posture")
+
+        if re.search(r"\bcheck these (?:four )?faxes\b|\bfor each item\b|\bindicate whether\b", text):
+            add("Compliance Program Review", 1.0, "compliance_checklist_style")
+
+        if re.search(r"\b8-k\b|\bform 8-k\b|\bsec\b|\brule 10b-5\b|\breg fd\b", text):
+            add("Compliance Program Review", 1.4, "sec_disclosure_context")
+            add("Legal Research", 0.8, "sec_disclosure_context")
+
+        if re.search(r"\breview\b.{0,30}\bagreement\b", text) and re.search(r"\bcan\b|\bmay\b|\bvalid\b", text):
+            add("Contract Review", 1.1, "agreement_interpretation")
+
+        if re.search(r"\bbreach\b|\boutage\b", text) and re.search(r"\bincident report\b|\bpostmortem\b", text):
+            add("Internal Investigations", 1.5, "breach_incident_combo")
+
+        if re.search(
+            r"\bcapital account\b|\bamounts? to be distributed\b|\bchild support\b|\bmaximum refund amount\b",
+            text,
+        ):
+            add("Other", 1.8, "quantitative_legal_calculation")
+
+    return scores, reasons
+
+
+def _quota_assign(
+    task_ids: list[str],
+    scores_by_task: dict[str, dict[str, float]],
+    workflow_quotas: dict[str, int],
+    domain: str,
+) -> dict[str, str]:
+    slots: list[str] = []
+    for workflow, count in workflow_quotas.items():
+        slots.extend([workflow] * count)
+
+    if len(task_ids) != len(slots):
+        raise ValueError(
+            f"{domain} task count ({len(task_ids)}) does not match workflow quota total ({len(slots)})."
+        )
+
+    score_matrix = np.zeros((len(task_ids), len(slots)), dtype=np.float64)
+    for row_idx, task_id in enumerate(task_ids):
+        scores = scores_by_task[task_id]
+        for col_idx, workflow in enumerate(slots):
+            score_matrix[row_idx, col_idx] = scores[workflow]
+
+    row_ind, col_ind = linear_sum_assignment(-score_matrix)
+    assignments: dict[str, str] = {}
+    for row_idx, col_idx in zip(row_ind, col_ind):
+        assignments[task_ids[row_idx]] = slots[col_idx]
+    return assignments
+
+
+def _score_rank(scores: dict[str, float], assigned_workflow: str) -> int:
+    sorted_items = sorted(scores.items(), key=lambda item: item[1], reverse=True)
+    for idx, (workflow, _) in enumerate(sorted_items, start=1):
+        if workflow == assigned_workflow:
+            return idx
+    return len(sorted_items)
+
+
+def _confidence(scores: dict[str, float], assigned_workflow: str) -> float:
+    vals = sorted(scores.values(), reverse=True)
+    top = vals[0]
+    second = vals[1] if len(vals) > 1 else vals[0]
+    assigned = scores[assigned_workflow]
+    margin = assigned - second if assigned == top else assigned - top
+    spread = max(vals) - min(vals) + 1e-6
+    scaled = margin / (spread / 2.0 + 1e-6)
+    return 1.0 / (1.0 + math.exp(-scaled))
+
+
+def _augment_tasks(tasks: list[dict], task_file_index: dict[str, str]) -> tuple[list[dict], list[dict]]:
+    domain_scores: dict[str, dict[str, dict[str, float]]] = {}
+    domain_reasons: dict[str, dict[str, dict[str, list[str]]]] = {}
+    domain_assignments: dict[str, dict[str, str]] = {}
+
+    for domain, quotas in DOMAIN_WORKFLOW_QUOTAS.items():
+        domain_tasks = [task for task in tasks if task.get("domain") == domain]
+        task_ids = [task["task_id"] for task in domain_tasks]
+
+        scores_by_task: dict[str, dict[str, float]] = {}
+        reasons_by_task: dict[str, dict[str, list[str]]] = {}
+        for task in domain_tasks:
+            task_id = task["task_id"]
+            file_hints = task_file_index.get(task_id, "")
+            scores, reasons = _score_task(task, file_hints)
+            scores_by_task[task_id] = scores
+            reasons_by_task[task_id] = reasons
+
+        assignments = _quota_assign(task_ids, scores_by_task, quotas, domain)
+        domain_scores[domain] = scores_by_task
+        domain_reasons[domain] = reasons_by_task
+        domain_assignments[domain] = assignments
+
+    augmented: list[dict] = []
+    audit_rows: list[dict] = []
+
+    for task in tasks:
+        task_copy = dict(task)
+        domain = task_copy.get("domain")
+        if domain in DOMAIN_WORKFLOW_QUOTAS:
+            task_id = task_copy["task_id"]
+            workflow = domain_assignments[domain][task_id]
+            scores = domain_scores[domain][task_id]
+            conf = _confidence(scores, workflow)
+            rank = _score_rank(scores, workflow)
+
+            task_copy["workflow"] = workflow
+            task_copy["workflow_inference"] = {
+                "source": "heuristic_quota_constrained_v2_all_domains",
+                "confidence": round(conf, 4),
+                "assigned_score_rank": rank,
+                "reason_signals": domain_reasons[domain][task_id].get(workflow, [])[:6],
+                "paper_domain_quota_aligned": True,
+            }
+
+            sorted_scores = sorted(scores.items(), key=lambda item: item[1], reverse=True)
+            audit_rows.append(
+                {
+                    "domain": domain,
+                    "task_id": task_id,
+                    "task_name": task_copy.get("task_name", ""),
+                    "workflow": workflow,
+                    "confidence": f"{conf:.4f}",
+                    "assigned_score_rank": rank,
+                    "top1_workflow": sorted_scores[0][0],
+                    "top1_score": f"{sorted_scores[0][1]:.3f}",
+                    "top2_workflow": sorted_scores[1][0],
+                    "top2_score": f"{sorted_scores[1][1]:.3f}",
+                    "top3_workflow": sorted_scores[2][0],
+                    "top3_score": f"{sorted_scores[2][1]:.3f}",
+                    "assigned_signals": " | ".join(domain_reasons[domain][task_id].get(workflow, [])[:6]),
+                }
+            )
+
+        augmented.append(task_copy)
+
+    return augmented, audit_rows
+
+
+def _write_audit_csv(rows: list[dict], path: Path) -> None:
+    fieldnames = [
+        "domain",
+        "task_id",
+        "task_name",
+        "workflow",
+        "confidence",
+        "assigned_score_rank",
+        "top1_workflow",
+        "top1_score",
+        "top2_workflow",
+        "top2_score",
+        "top3_workflow",
+        "top3_score",
+        "assigned_signals",
+    ]
+    with path.open("w", encoding="utf-8", newline="") as fp:
+        writer = csv.DictWriter(fp, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--input",
+        type=Path,
+        default=Path("tasks_and_rubrics.json"),
+        help="Input task JSON file.",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("tasks_and_rubrics_with_workflow.json"),
+        help="Output JSON file with inferred `workflow` labels.",
+    )
+    parser.add_argument(
+        "--task-files-root",
+        type=Path,
+        default=Path("task_files"),
+        help="Root folder containing `task_<id>` subfolders.",
+    )
+    parser.add_argument(
+        "--audit-output",
+        type=Path,
+        default=Path("workflow_inference_audit.csv"),
+        help="CSV path for per-task assignment diagnostics.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    tasks = json.loads(args.input.read_text(encoding="utf-8"))
+    if not isinstance(tasks, list):
+        raise ValueError("Input JSON must be an array of task objects.")
+
+    task_file_index = _build_task_file_index(args.task_files_root)
+    augmented_tasks, audit_rows = _augment_tasks(tasks, task_file_index)
+
+    args.output.write_text(json.dumps(augmented_tasks, indent=2, ensure_ascii=False), encoding="utf-8")
+    _write_audit_csv(audit_rows, args.audit_output)
+
+    print(f"Wrote {args.output} ({len(augmented_tasks)} tasks)")
+    print(f"Wrote {args.audit_output} ({len(audit_rows)} labeled tasks)")
+    for domain, quotas in DOMAIN_WORKFLOW_QUOTAS.items():
+        distribution = Counter(
+            task.get("workflow")
+            for task in augmented_tasks
+            if task.get("domain") == domain
+        )
+        print(f"Inferred {domain} workflow distribution:")
+        for workflow in quotas:
+            print(f"  {workflow}: {distribution.get(workflow, 0)}")
+
+
+if __name__ == "__main__":
+    main()