Add reference-harness prompts

prompts/__init__.py

@@ -0,0 +1,49 @@
+"""
+Prompts package (hypothesis_orchestrated v2).
+
+Active prompts: orientation, planning, system, scheme/hypothesis workers, compaction.
+Retired PER-phase prompts (reflection, synthesis, cross-scheme, replan, phase_summary,
+legacy worker orchestration) were removed — see git history.
+"""
+
+from .compaction import COMPACTION_PROMPT
+from .fraud_catalogue import FRAUD_CATALOGUE
+from .hypothesis_worker import (
+    build_hypothesis_summary_prompt,
+    build_hypothesis_worker_prompt,
+    build_worker_brief_prompt,
+    build_worker_summary_prompt,
+    parse_hypothesis_summary_json,
+)
+from .minimal_scheme_cards import build_minimal_scheme_cards
+from .missions import TASK_MISSIONS
+from .orientation import (
+    ORIENTATION_PROMPT,
+    build_orientation_kickoff_message,
+    build_orientation_prompt,
+)
+from .planning import build_planning_prompt
+from .react_suffix import REACT_SUFFIX
+from .schema import DB_SCHEMA
+from .scheme_phase import build_scheme_phase_prompt
+from .system_prompt import build_system_prompt
+
+__all__ = [
+    "DB_SCHEMA",
+    "FRAUD_CATALOGUE",
+    "TASK_MISSIONS",
+    "build_minimal_scheme_cards",
+    "build_system_prompt",
+    "ORIENTATION_PROMPT",
+    "build_orientation_prompt",
+    "build_orientation_kickoff_message",
+    "build_planning_prompt",
+    "build_scheme_phase_prompt",
+    "build_hypothesis_worker_prompt",
+    "build_hypothesis_summary_prompt",
+    "parse_hypothesis_summary_json",
+    "build_worker_brief_prompt",
+    "build_worker_summary_prompt",
+    "COMPACTION_PROMPT",
+    "REACT_SUFFIX",
+]

prompts/compaction.py

@@ -0,0 +1,13 @@
+COMPACTION_PROMPT = """Summarise the key findings, hypotheses tested, evidence discovered, and any dead ends from the investigation steps above.
+
+Your goal is to produce a **rich, highly detailed memory summary** that can be safely reused later, up to the memory summary token budget provided in the system instructions. Do **not** self-limit to a few hundred tokens; instead, use as much detail as is useful while staying within that budget.
+
+The summary MUST explicitly preserve:
+- Entity IDs (employee, vendor, customer) that are suspicious
+- Document IDs that have been flagged
+- GL account numbers that showed anomalies
+- Monetary amounts and date ranges
+- Which scheme types each finding relates to
+- Open hypotheses and next investigation steps
+
+Do NOT include raw SQL queries or full table outputs — only the conclusions drawn from them."""

prompts/fraud_catalogue.py

@@ -0,0 +1,85 @@
+FRAUD_CATALOGUE = """
+## Known Fraud Scheme Catalogue
+
+**Only these 5 scheme types exist in the data** (no other fraud types are injected).
+Each entry describes the **business process**, what “healthy” operations look like in substance,
+and the **kinds of breakdown** that can indicate manipulation. It does **not** name expected GL
+accounts, auxiliary formats, posting templates, or calendar cutoffs — those must come from **your**
+profiling of this dataset (chart of accounts, distributions, joins, and master data).
+
+---
+
+### 1. Fictitious AP Disbursements
+
+**Normal process (substance):** The organisation should only settle payables for goods or services
+that were ordered, received or accepted, and invoiced under segregation of duties (e.g. different
+actors for recording vs authorising payment). Vendor identity and payment references should be
+consistent with normal operating practice.
+
+**When something is wrong (conceptual):** Value may leave the entity without a defensible
+procurement-to-pay trail: missing or weak evidence of receipt or approval, payables cleared without
+a credible invoice trail, the same actors repeatedly spanning incompatible roles, timing or
+vendor populations that diverge sharply from the rest of the ledger, or reference behaviour that
+does not match how the company usually books AP and bank movements.
+
+---
+
+### 2. Revenue Manipulation (Window Dressing)
+
+**Normal process (substance):** Revenue aligns with delivery or completion of performance
+obligations; expenses and provisions are recognised in the appropriate periods; releases of
+reserves or similar items require defensible economic events and governance.
+
+**When something is wrong (conceptual):** Earnings can be inflated by recognising revenue too early,
+pushing expenses out of the period, or releasing balances that should still reflect risk or
+obligation. Suspect patterns are **relative**: unusual concentration in time, abnormal mixes of
+lines or accounts for the same commercial story, or journal narratives and flows that do not
+cohere with the rest of the order-to-cash and record-to-report activity in **this** database.
+
+---
+
+### 3. Vendor Collusion (Kickback + Related-Party)
+
+**Normal process (substance):** Procurement and payment follow approved sourcing, pricing, and
+approval chains; vendors are genuine third parties at arm’s length; segregation limits a single
+actor from controlling selection, invoicing, and payment.
+
+**When something is wrong (conceptual):** Inflated or biased spend, repeated coupling of the same
+internal and external parties without rotation, payment behaviour that fragments or obscures totals,
+weak master-data linkage, or indications that beneficiary or party data overlaps with insiders.
+Signals are contextual: compare to peer vendors, amounts, and approval patterns in the same data.
+
+---
+
+### 4. Shadow Payroll (Ghost Employee)
+
+**Normal process (substance):** Payroll pays real employees under HR and payroll policies, with
+accruals and settlements that match the entity’s payroll design (which may include multiple line
+types, schedules, and banking arrangements you must infer from the data).
+
+**When something is wrong (conceptual):** Beneficiaries or pay runs that are structurally odd
+relative to the population (e.g. accrual shape, timing clusters, banking or institution patterns,
+recency of employment lifecycle events vs pay activity, or concentration of authorship) can indicate
+diversion or synthetic beneficiaries. **Plausible HR rows do not rule out fraud** — treat master
+data as necessary context, not as a whitelist.
+
+---
+
+### 5. Inventory Manipulation (Asset Misappropriation)
+
+**Normal process (substance):** Inventory moves should trace to economic events (receipts,
+consumption, sales, authorised adjustments). Write-downs and adjustments require authorised,
+documented physical or operational justification.
+
+**When something is wrong (conceptual):** Stock increases without credible upstream support,
+write-offs disconnected from prior stock history, suspicious symmetry or pairing of movements,
+period-close clustering of adjustments vs norms, or split roles across related postings may indicate
+inflation, concealment, or misappropriation. Map **this** entity’s inventory-related accounts and
+references from the ledger before concluding.
+
+---
+
+**How to use this catalogue:** Use it to frame **hypotheses** and **questions**, not as a
+checklist of built-in tests. All concrete controls, accounts, SQL filters, and thresholds must be
+**derived and validated** against the chart of accounts and facts in the database.
+""".strip()

prompts/hypothesis_worker.py

@@ -0,0 +1,164 @@
+"""Prompts for per-hypothesis investigation workers (core_spec v2)."""
+from __future__ import annotations
+
+import json
+
+from researchpkg.forensic_llm.config import (
+    TextTruncationLimits,
+)
+from researchpkg.forensic_llm.models import (
+    HypothesisTaskBrief,
+    WorkerBrief,
+)
+from researchpkg.forensic_llm.prompts.investigation_discipline import (
+    COMPREHENSIVE_INVESTIGATION_GUIDANCE,
+    HYPOTHESIS_INVESTIGATION_DEPTH,
+    REPORT_SUSPICION_DISCIPLINE,
+)
+from researchpkg.forensic_llm.text_truncation import (
+    TruncationSide,
+    truncate_text_to_tokens,
+)
+
+
+def build_hypothesis_worker_prompt(
+    brief: HypothesisTaskBrief,
+    text_limits: TextTruncationLimits | None = None,
+) -> str:
+    lim = text_limits or TextTruncationLimits()
+    shared = brief.shared_context or {}
+    shared_excerpt = truncate_text_to_tokens(
+        shared.get("global_memory_excerpt", "") or "",
+        lim.hypothesis_worker_shared_memory,
+        side=TruncationSide.TAIL,
+    )
+    peer_block = ""
+    peers = shared.get("peer_hypothesis_summaries") or []
+    if peers:
+        peer_block = "\n**Peer hypotheses (same scheme):**\n" + "\n".join(
+            f"- {p.get('hypothesis_id')}: {p.get('status')} — {p.get('key_finding', '')}"
+            for p in peers
+        )
+
+    return (
+        f"## Hypothesis investigation task: `{brief.task_id}`\n\n"
+        f"- **Scheme:** `{brief.scheme}`\n"
+        f"- **Hypothesis ID:** `{brief.hypothesis_id}`\n"
+        f"- **Token budget:** {brief.budget_tokens:,} (the planner allocated this envelope for **your** hypothesis — treat it as a target to work toward through SQL + reasoning, not a ceiling to leave mostly unused)\n\n"
+        f"### Hypothesis\n{brief.hypothesis_text}\n\n"
+        + (
+            f"### Why this task (planner rationale)\n{brief.hypothesis_rationale}\n\n"
+            if (brief.hypothesis_rationale or "").strip()
+            else ""
+        )
+        + f"### Exit criteria\n"
+        + "\n".join(f"- {c}" for c in brief.exit_criteria)
+        + "\n\n"
+        f"### Benign rival explanations to falsify\n"
+        + "\n".join(f"- {b}" for b in brief.benign_rivals)
+        + "\n\n"
+        f"### Planned query families\n"
+        + "\n".join(f"- {q}" for q in brief.planned_query_families)
+        + "\n\n"
+        f"### Shared context\n```\n{shared_excerpt}\n```\n" + peer_block + "\n\n"
+        "### Operating rules\n"
+        "1. Investigate **only** this hypothesis — but investigate it **thoroughly** (screen → drill → "
+        "falsify benign rivals → follow material leads). **Spend most of your allocated token budget** "
+        "unless you reach a decisive verdict very early with dense SQL evidence.\n"
+        "2. Use the **planned query families** unless evidence justifies a documented deviation "
+        "(note in scratchpad).\n"
+        "3. **`report_suspicion`** whenever you have SQL-backed suspicious `je_header.document_id` UUIDs "
+        "— during investigation, not only in the summary.\n"
+        "4. Use `blackboard_write` for entity findings relevant to other schemes.\n"
+        "5. Do **not** call `finish_investigation`.\n"
+        "6. Stop tool use only when the verdict is evidence-backed — a summary step follows.\n"
+        "7. **Budget:** the scratchpad *Run context* shows **Task input budget** (% used / "
+        "remaining). If SQL-backed evidence confirms fraud, call `report_suspicion` *before* "
+        "you exhaust that cap—do not plan heavy exports when the % is already high.\n\n"
+        + HYPOTHESIS_INVESTIGATION_DEPTH
+        + "\n"
+        + COMPREHENSIVE_INVESTIGATION_GUIDANCE
+        + "\n"
+        + REPORT_SUSPICION_DISCIPLINE
+    )
+
+
+def build_hypothesis_summary_prompt(
+    brief: HypothesisTaskBrief,
+    text_limits: TextTruncationLimits | None = None,
+) -> str:
+    lim = text_limits or TextTruncationLimits()
+    hyp_text = truncate_text_to_tokens(
+        brief.hypothesis_text or "",
+        lim.hypothesis_worker_hypothesis_text,
+        side=TruncationSide.HEAD,
+    ).replace('"', "'")
+    hyp_rat = truncate_text_to_tokens(
+        brief.hypothesis_rationale or "",
+        lim.hypothesis_rationale_store,
+        side=TruncationSide.TAIL,
+    ).replace('"', "'")
+    return (
+        f"Produce the structured JSON summary for hypothesis `{brief.hypothesis_id}` "
+        f"on scheme `{brief.scheme}`. Respond with ONLY the JSON object.\n\n"
+        "**`flagged_document_ids`:** must match every UUID you reported via `report_suspicion` "
+        "during this task (same IDs from SQL). If status is `confirmed` and you have exemplar JEs, "
+        "this list must be non-empty. Use `[]` only when status is `falsified`.\n\n"
+        "```json\n"
+        "{\n"
+        f'  "scheme": "{brief.scheme}",\n'
+        f'  "hypothesis_id": "{brief.hypothesis_id}",\n'
+        f'  "hypothesis_text": "{hyp_text}",\n'
+        f'  "hypothesis_rationale": "{hyp_rat}",\n'
+        '  "status": "<confirmed|falsified|inconclusive>",\n'
+        '  "finish_reason": "<completed|task_budget_stop_frac|task_budget_exhausted|worker_error>",\n'
+        '  "flagged_document_ids": ["<uuid>", "..."],\n'
+        '  "flagged_entities": ["<entity_id>", "..."],\n'
+        '  "key_findings": "<2-4 sentences: what you tested, what data showed, verdict rationale>",\n'
+        '  "evidence_checks_run": ["<screen>", "<drill>", "<benign rival>", "..."],\n'
+        '  "benign_rivals_considered": ["..."],\n'
+        '  "open_questions": ["..."],\n'
+        '  "error": null\n'
+        "}\n"
+        "```"
+    )
+
+
+def build_worker_brief_prompt(brief: WorkerBrief) -> str:
+    """Legacy autonomous worker brief (deprecated path)."""
+    candidate_schemes = (
+        ", ".join(brief.candidate_schemes) if brief.candidate_schemes else "unspecified"
+    )
+    return (
+        f"## Worker Brief: {brief.worker_id}\n\n"
+        f"- Goal: `{brief.scheme_or_goal}`\n"
+        f"- Candidate schemes: {candidate_schemes}\n"
+        f"- Budget tokens: {brief.budget_tokens:,}\n\n"
+        f"{brief.brief}\n\n"
+        "Do not call `finish_investigation`. Use `report_suspicion` for confirmed JEs."
+    )
+
+
+def build_worker_summary_prompt(brief: WorkerBrief) -> str:
+    """Legacy autonomous worker summary (deprecated path)."""
+    return (
+        f"Summarize worker `{brief.worker_id}` as JSON only.\n"
+        '{"worker_id": "...", "scheme_or_goal": "...", "status": "completed", '
+        '"flagged_document_ids": ["<uuid>"], "key_findings": "..."}'
+    )
+
+
+def parse_hypothesis_summary_json(text: str, brief: HypothesisTaskBrief) -> dict:
+    from researchpkg.forensic_llm.json_utils import (
+        extract_first_json_object,
+    )
+
+    obj = extract_first_json_object(text or "") or {}
+    obj.setdefault("scheme", brief.scheme)
+    obj.setdefault("hypothesis_id", brief.hypothesis_id)
+    obj.setdefault("hypothesis_text", brief.hypothesis_text)
+    obj.setdefault("hypothesis_rationale", brief.hypothesis_rationale)
+    obj.setdefault("status", "inconclusive")
+    if "finish_reason" not in obj:
+        obj["finish_reason"] = None
+    return obj

prompts/investigation_discipline.py

@@ -0,0 +1,115 @@
+"""Shared investigation discipline blocks for prompts."""
+
+TOOL_NEUTRAL_OPERATING = (
+    "Every tool call must serve a specific, falsifiable hypothesis: surface a signal, "
+    "discriminate rival explanations, or retrieve JE-level evidence. Choose the tool "
+    "that fits the question — do not default to sql preview when population-level analysis, "
+    "graphs, or exports are the right next step."
+)
+
+TOOL_SELECTION_GUIDANCE = """
+### Tool selection (no SQL default)
+| Need | Preferred tools |
+|------|-----------------|
+| Aggregates, filters, small result sets | `sql` with `mode='preview'` (default max_rows 50) |
+| Full population, >50 rows, Benford, distributions, clustering | `sql` with `mode='export'` → `code_interpreter` → `read_image` if charted |
+| Vendor–employee bank overlap, circular payments, related-party paths | `sql(mode='export')` + `code_interpreter` (NetworkX joins on exported tables) |
+| Flagging specific journal entries | `sql` preview/export + filter in `code_interpreter`, then `report_suspicion` when appropriate |
+
+**Anti-patterns:** repeated `sql` preview with arbitrary `LIMIT` when the answer needs the full population; finishing a hypothesis after one null preview without reformulation or export-and-analyze; entity-level conclusions without supporting transaction evidence when JEs exist.
+"""
+
+HYPOTHESIS_FORMATION_GUIDANCE = """
+### Hypothesis formation (planning)
+Form **ranked, testable** investigation angles from orientation evidence — write in **plain forensic
+language**, not a rigid template.
+
+**Do not** use boilerplate ``If … then …`` phrasing. Each hypothesis needs two fields:
+- ``hypothesis_text``: a concise claim about what might be wrong (one or two sentences).
+- ``hypothesis_rationale``: **one paragraph** tying the claim to orientation signals, what SQL or
+  analysis would test it, and what outcome would support vs rule out the scheme (including one
+  plausible benign rival).
+
+Other rules:
+- Assign **P1, P2, …** within each scheme (P1 = strongest angle for that scheme).
+- **Cover the forensic surface area** before merging ideas: entities & master data, timing & cut-off,
+  amounts & concentration, approvals & segregation, period-end behavior, control-account
+  reconciliations, and cross-party links (vendor↔customer↔employee) where data allows.
+  One queue entry ≈ one distinct test.
+- **Prefer breadth over a single umbrella line** per scheme: high-risk schemes deserve many distinct
+  angles; lower-priority schemes still need enough lines for a credible RULED_OUT.
+- In ``dispatch_queue``, list rows in **P-wave order** (all schemes' ``P1``, then all ``P2``, …); do not block by scheme.
+- Every ``dispatch_queue`` entry must include both ``hypothesis_text`` and ``hypothesis_rationale``.
+- Mirror the same ``P`` ids, text, and rationale in ``phases[].initial_hypotheses`` (as objects, not
+  legacy string lines).
+"""
+
+COMPREHENSIVE_INVESTIGATION_GUIDANCE = """
+### Comprehensive investigation standard (prompt discipline — not a step quota)
+Treat this engagement like a **full forensic file**, not a quick anomaly scan. Depth comes from
+**evidence quality**, not from repeating the same query.
+
+**Orientation & planning**
+- Build measured baselines (rates, concentrations, period structure) before accusing fraud.
+- Plans should enumerate **distinct** hypotheses and concrete query families per scheme — workers
+  inherit your brief; vague plans produce shallow tasks.
+
+**Per-hypothesis execution**
+- Typical thorough path: **screen** (does the signal exist?) → **drill** (who/what/when/how much?) →
+  **falsify a benign rival** (could this be process design, master-data gap, or IC timing?) →
+  **discriminative check** when populations are large → **`report_suspicion`** for exemplar JEs.
+- A null or weak screen is not a verdict: reformulate (different join, window, account slice, or
+  export-and-analyze) before RULED_OUT.
+- When a pattern is material, trace **follow-on questions** (linked accounts, same actor, adjacent
+  periods, monetary roll-up) until the story is complete or clearly explained away.
+- Use **`sql(mode='export')` + `code_interpreter`** whenever the question is about distributions,
+  rates, concentration, or >50 rows — previews are for EXISTS and small top-k, not population proof.
+
+**When to stop on a hypothesis**
+- Stop when you can defend CONFIRMED / RULED_OUT / INCONCLUSIVE with cited SQL outcomes — not when
+  you have merely run a few queries. Premature closure wastes the budget and misses fraud.
+"""
+
+HYPOTHESIS_INVESTIGATION_DEPTH = """
+### Hypothesis investigation depth
+Use **as many tool calls as the hypothesis requires** (`sql`, `code_interpreter`, `read_image`).
+There is no target query count — there is a **standard of proof**.
+
+Before a verdict, you should usually have:
+- screened whether the signal exists in the population,
+- drilled into the strongest candidates (entities, amounts, periods, control bypass),
+- tested at least one **plausible benign rival** explanation with data,
+- retrieved `document_id` UUIDs for any JEs you will report or reference.
+
+If a screening step returns zero rows, reformulate once (time window, account range, join path, or
+export-and-analyze) before RULED_OUT. If a pattern is confirmed, consider whether adjacent slices
+(same user, vendor, period cluster) warrant a short follow-up before closing the hypothesis.
+"""
+
+DISCRIMINATIVENESS_BEFORE_FLAG = """
+Before `report_suspicion`, verify the signal is **discriminative**.
+Use `sql(mode='export')` + `code_interpreter` to compare flagged vs non-flagged rates when the population is large.
+"""
+
+REPORT_SUSPICION_DISCIPLINE = """
+### JE reporting (`report_suspicion`) — required for evaluation
+Benchmark scoring uses **`detections.json`**, which is populated **only** via `report_suspicion`
+(not from scratchpad prose alone).
+
+**When you MUST call `report_suspicion`:**
+- You retrieved one or more `je_header.document_id` UUIDs that exemplify the fraud pattern for this hypothesis.
+- Status is **CONFIRMED** with clear SQL-backed evidence — include exemplar JEs only (not every row in a large export).
+- After `sql`/`code_interpreter` identifies a bounded set of suspicious postings — report **before** stopping tool use.
+
+**How to report:**
+- Prefer batch: `suspicions: [{document_id, scheme_type, rationale}, ...]` (up to ~50 per call; repeat if needed).
+- `document_id` = UUID from column `document_id` / `jh.document_id` only — never reference, line_number, or auxiliary account.
+- `scheme_type` = the task scheme (e.g. `shadow_payroll`).
+
+**When NOT to report:** hypothesis **RULED OUT** with no suspicious JEs after reformulation — leave detections empty.
+
+**Workflow:** screen → drill → (optional discriminative check) → **`report_suspicion`** → scratchpad verdict.
+"""
+
+# Back-compat alias for imports that still reference the old name.
+GROUNDING_AFTER_CONFIRMED = HYPOTHESIS_INVESTIGATION_DEPTH

prompts/minimal_scheme_cards.py

@@ -0,0 +1,81 @@
+SCHEME_CARDS = {
+    "fictitious_ap_disbursements": {
+        "process_anchor": "P2P / accounts payable / disbursements",
+        "economic_meaning": (
+            "Cash leaves the company for goods or services that were not genuinely "
+            "received, approved, or owed."
+        ),
+    },
+    "revenue_manipulation": {
+        "process_anchor": "O2C and R2R / revenue recognition / period close",
+        "economic_meaning": (
+            "Revenue, expense timing, or reserves are adjusted to inflate current-period "
+            "earnings (early revenue, expense deferral, reserve release)."
+        ),
+    },
+    "vendor_collusion": {
+        "process_anchor": "Procurement / vendor onboarding / invoice approval",
+        "economic_meaning": (
+            "An internal actor and an external vendor coordinate to divert value "
+            "through biased, inflated, or related-party purchasing activity."
+        ),
+    },
+    "shadow_payroll": {
+        "process_anchor": "H2R / payroll / employee master data",
+        "economic_meaning": (
+            "Payroll is diverted to a synthetic or colluding beneficiary, often "
+            "onboarded in HR with plausible identity "
+        ),
+    },
+    "inventory_manipulation": {
+        "process_anchor": "Inventory / stock movements / write-offs / close",
+        "economic_meaning": (
+            "Inventory is inflated, concealed, or written off in a way that is not "
+            "consistent with real stock movement or physical operations."
+        ),
+    },
+}
+
+
+def build_minimal_scheme_cards(task: str = "full") -> str:
+    """
+    Render a minimal closed-world scheme catalogue.
+
+    This variant provides only high-level business-process anchors and economic meaning.
+    It avoids prescribing investigative angles, control checks, SQL patterns, or expected
+    anomaly signatures so the model must derive its own path from the ledger.
+    """
+
+    if task != "full" and task in SCHEME_CARDS:
+        keys = [task]
+    else:
+        keys = list(SCHEME_CARDS.keys())
+
+    lines = [
+        "## Closed-World Scheme Cards",
+        "",
+        "The benchmark contains only the scheme families listed below.",
+        "These are problem labels and process anchors, not solution templates.",
+        "You are NOT given expected SQL tests, control-failure checklists, or",
+        "known account patterns. You must derive those from the ledger.",
+        "",
+    ]
+
+    for idx, key in enumerate(keys, start=1):
+        card = SCHEME_CARDS[key]
+        lines.append(f"### {idx}. {key}")
+        lines.append(f"- Process anchor: {card['process_anchor']}")
+        lines.append(f"- Economic meaning: {card['economic_meaning']}")
+        lines.append("")
+
+    allowed = ", ".join(
+        keys if task != "full" and task in SCHEME_CARDS else SCHEME_CARDS
+    )
+    lines.extend(
+        [
+            "Allowed final labels:",
+            f"- {allowed}",
+            "- unknown",
+        ]
+    )
+    return "\n".join(lines)

prompts/missions.py

@@ -0,0 +1,72 @@
+TASK_MISSIONS: dict[str, str] = {
+    "full": (
+        "Your mission is a **comprehensive forensic investigation** focused exclusively "
+        "on the five fraud schemes in the catalogue. You have no prior knowledge of "
+        "which schemes, if any, are present in this ledger. "
+        "Apply the full fraud catalogue: (1) fictitious AP disbursements, (2) revenue "
+        "manipulation, (3) vendor collusion, (4) shadow payroll, "
+        "and (5) inventory manipulation. "
+        "Begin with a broad orientation of the ledger, then form and test hypotheses "
+        "systematically across these five scheme types only. "
+        "**You have a large investigation budget — treat this as a full engagement, not a quick scan. "
+        "A superficial investigation that finishes early is a failed investigation. "
+        "Use your budget to go deep: multiple hypotheses per scheme, multiple queries per hypothesis, "
+        "drill-down on every promising lead before moving on.**"
+    ),
+    # -----------------------------------------------------------------------
+    # Per-scheme missions used by parallel worker agents.
+    # Each worker investigates exactly one scheme in isolation.
+    # -----------------------------------------------------------------------
+    "fictitious_ap_disbursements": (
+        "Your mission is a **focused investigation of fictitious AP disbursements** "
+        "(salami-slicing via fictitious invoices, expense-laundering through real vendors, "
+        "systematic small-amount diversions to shell or front vendors). "
+        "You are a **parallel worker** — other agents are simultaneously investigating "
+        "the four other fraud schemes. Do NOT investigate other scheme types. "
+        "Prioritise your queries on AP-cycle JEs, below-threshold payments, repeated small credits "
+        "to the same GL/vendor, suspense account activity, and vendor master anomalies. "
+        "Call `report_suspicion` immediately for every confirmed finding. "
+        "Do NOT call `finish_investigation`."
+    ),
+    "revenue_manipulation": (
+        "Your mission is a **focused investigation of revenue manipulation** "
+        "(quarter-end inflation, premature recognition, next-period reversals). "
+        "You are a **parallel worker** — other agents are simultaneously investigating "
+        "the four other fraud schemes. Do NOT investigate other scheme types. "
+        "Prioritise your queries on revenue GL accounts, period-end postings, "
+        "manual journal entries, and reversal patterns. "
+        "Call `report_suspicion` immediately for every confirmed finding. "
+        "Do NOT call `finish_investigation`."
+    ),
+    "vendor_collusion": (
+        "Your mission is a **focused investigation of vendor collusion** "
+        "(inflated invoices with kickbacks, related-party undisclosed relationships, "
+        "vendor-employee bank account sharing, insider approval of affiliated-vendor payments). "
+        "You are a **parallel worker** — other agents are simultaneously investigating "
+        "the four other fraud schemes. Do NOT investigate other scheme types. "
+        "Prioritise your queries on vendor payment amounts, vendor–employee relationships, "
+        "bank account cross-matches, high-value single-vendor concentration, and approval metadata. "
+        "Call `report_suspicion` immediately for every confirmed finding. "
+        "Do NOT call `finish_investigation`."
+    ),
+    "shadow_payroll": (
+        "Your mission is a **focused investigation of shadow payroll fraud** "
+        "(ghost employees, payroll diversions, and terminated-employee payments). "
+        "You are a **parallel worker** — other agents are simultaneously investigating "
+        "the four other fraud schemes. Do NOT investigate other scheme types. "
+        "Prioritise your queries on payroll-related GL accounts, the employees table, "
+        "and je_header/je_line entries linked to payroll postings. "
+        "Call `report_suspicion` immediately for every confirmed finding. "
+        "Do NOT call `finish_investigation`."
+    ),
+    "inventory_manipulation": (
+        "Your mission is a **focused investigation of inventory manipulation** "
+        "(fictitious receipt postings, write-off abuse, shrinkage overstatement). "
+        "You are a **parallel worker** — other agents are simultaneously investigating "
+        "the four other fraud schemes. Do NOT investigate other scheme types. "
+        "Prioritise your queries on inventory GL accounts, goods-receipt JEs, "
+        "write-off entries, and cost-of-goods postings. "
+        "Call `report_suspicion` immediately for every confirmed finding. "
+        "Do NOT call `finish_investigation`."
+    ),
+}

prompts/orchestrator_followup.py

@@ -0,0 +1,83 @@
+"""Orchestrator follow-up hypothesis proposal (core_spec v2 dynamic queue)."""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List
+
+from researchpkg.forensic_llm.config import (
+    TextTruncationLimits,
+)
+from researchpkg.forensic_llm.models import (
+    HypothesisResult,
+)
+from researchpkg.forensic_llm.text_truncation import (
+    TruncationSide,
+    truncate_text_to_tokens,
+)
+
+
+def build_orchestrator_followup_prompt(
+    last_result: HypothesisResult,
+    global_excerpt: str,
+    existing_task_ids: List[str],
+    max_proposals: int = 2,
+    text_limits: TextTruncationLimits | None = None,
+) -> str:
+    """Compact one-shot prompt — no orientation conversation history."""
+    lim = text_limits or TextTruncationLimits()
+    result_json = truncate_text_to_tokens(
+        json.dumps(last_result.model_dump(mode="json"), indent=2, default=str),
+        lim.orchestrator_followup_json,
+        side=TruncationSide.TAIL,
+    )
+    memory_excerpt = truncate_text_to_tokens(
+        global_excerpt or "",
+        lim.orchestrator_followup_memory,
+        side=TruncationSide.TAIL,
+    )
+    return (
+        "## Orchestrator: propose follow-up hypothesis tasks\n\n"
+        "Based on the **just-completed** hypothesis result and shared memory, "
+        f"propose **0–{max_proposals}** new investigation tasks to run next. "
+        "Each task must be a **single distinct investigation angle** for one scheme (free-form text, "
+        "not ``If … then …`` boilerplate).\n\n"
+        f"**Completed task:** `{last_result.task_id}`\n"
+        f"```json\n{result_json}\n```\n\n"
+        f"**Shared memory excerpt:**\n```\n{memory_excerpt}\n```\n\n"
+        f"**Already queued or done (do not duplicate):** {', '.join(existing_task_ids[:40])}\n\n"
+        "Respond with **ONLY** a JSON array (no markdown fences):\n"
+        "[\n"
+        '  {"scheme": "<scheme_type>", "hypothesis_text": "<concise claim>", '
+        '"hypothesis_rationale": "<one paragraph: why now, what to test, confirm vs rule-out>", '
+        '"dispatch_priority": <int lower runs sooner>}\n'
+        "]\n\n"
+        "Rules:\n"
+        "- Prefer tracing entities, accounts, or JEs surfaced in `open_questions` or `key_findings`.\n"
+        "- Use an existing scheme from the fraud catalogue; do not invent scheme names.\n"
+        "- Empty array `[]` if no follow-up is justified.\n"
+    )
+
+
+def parse_followup_proposals(raw: str) -> List[Dict[str, Any]]:
+    """Parse LLM JSON array of follow-up proposals."""
+    text = (raw or "").strip()
+    if not text:
+        return []
+    if text.startswith("```"):
+        lines = text.split("\n")
+        text = "\n".join(lines[1:-1] if len(lines) > 2 else lines).strip()
+    start = text.find("[")
+    end = text.rfind("]")
+    if start < 0 or end <= start:
+        return []
+    try:
+        data = json.loads(text[start : end + 1])
+    except json.JSONDecodeError:
+        return []
+    if not isinstance(data, list):
+        return []
+    out: List[Dict[str, Any]] = []
+    for row in data:
+        if isinstance(row, dict) and row.get("hypothesis_text"):
+            out.append(row)
+    return out

prompts/orientation.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+ORIENTATION_MANDATORY_CHECKLIST = """\
+**Mandatory coverage before `complete_orientation`** — write like an investigator's **field notes**:
+dense explanatory prose first; tables are supporting evidence, not a substitute for understanding.
+
+**Every major `##` section must include:**
+- **2–5 paragraphs** (or equivalent bullet depth) explaining *what you learned*, *how entities link*,
+  *what is structurally normal here*, and *what planning should know* — with measured numbers woven in.
+- **At least one supporting table** only where it helps (vendor census, top-10 GL/aux/users, cross-tab);
+  never a report that is only tables with one-line captions.
+
+**Required topics** (exact `##` headings where noted):
+
+1. **`## Vendor / AP master`** — narrative on AP linkage (`auxiliary_gl_account` ↔ lines), P2P behavior,
+   self-balancing patterns; **plus** a table of **every** vendor:
+   `vendor_id` | `auxiliary_gl_account` | P2P lines | debit | credit | self-balancing docs.
+   **Call out** shell vendors `V-000021`–`V-000023` (same `V-{n:06}` / `401{n:04}` style as `V-000001`–`V-000020`);
+   contrast P2P volume, self-balancing doc share, and posters — not ID format alone.
+
+2. **`## Revenue / COA`** — explain COA membership vs `je_line` usage; revenue timing and posters;
+   **plus** each revenue GL for the latest material year (credit, line/JE counts). Resolve totals with SQL.
+
+3. **`## O2C × vendor/aux`** — explain whether vendor auxiliaries hit customer/O2C paths; **plus** cross-tab
+   or explicit zero-row proof with the filter used.
+
+4. **Structural baselines in prose** (dedicated `##` sections): schema/grain, process mix, fiscal/period-end
+   behavior, control-field coverage, user/actor tiers, reference patterns, per-process GL corridors.
+
+5. **Top-N summaries** — top 10 GL, top 10 aux, top 10 users: **table + short interpretation**
+   (why these dominate, which processes drive them).
+
+6. **`## Planning leads`** (single final section) — neutral **test intents** only; no fraud/scheme vocabulary.
+
+**Completion hygiene**
+- **No** `TBD`, `TODO`, “need to verify” — run follow-up SQL first.
+- **Banned** in orientation: fraud, suspicious, anomaly, red flag, scheme, manipulation, window dressing, etc.
+- **Bad:** 300 lines of tables and no ledger narrative. **Good:** rich prose sections with selective supporting tables.
+"""
+
+ORIENTATION_SCREENING_RULES = """\
+Begin a thorough **orientation / database profiling phase** for this ledger.
+
+**CRITICAL SEPARATION OF CONCERNS:**
+Your role in this phase is **DATABASE UNDERSTANDING ONLY** — build a comprehensive statistical and structural profile.
+**DO NOT** draw fraud conclusions, identify suspicious patterns, or form hypotheses. That happens in the **planning phase**.
+
+**Your mission:**
+1. Understand the **schema** — tables, keys, relationships, data types
+2. Profile the **structure** — chart of accounts, business processes, hierarchies
+3. Quantify **statistical distributions** — amounts, frequencies, time patterns
+4. Map **data linkages** — how master data connects to transactions
+5. Establish **baselines** — what "normal" looks like in this dataset
+
+**NO fraud conclusions yet.** Planning phase will use your profiles to design targeted tests.
+
+**Depth expectation:** Produce a **long, decision-ready** report — many `##` sections of **investigative
+narrative** (how the ledger works, how data links, what baselines look like), not a spreadsheet export.
+Planning reads the **raw orientation report** (first ~100k tokens); every critical baseline must be
+**explained in prose** in the report, not only in SQL you ran once.
+
+**No scratchpad.** Persist findings via `orientation_report(mode="append")` — **update the report often**
+(after each meaningful SQL or analysis batch, not only at the end).
+
+**Context layout every LLM call (fixed prefix):**
+1. **System prompt** — role, schema, tools
+2. **[Current Orientation Report]** — cumulative findings on disk
+3. **Recent steps** — last assistant/tool turns (token-capped; may truncate old SQL)
+4. **[Current Step]** — active checkpoint + in-flight SQL/tool output
+
+**Per-step workflow**
+1. Screen with `sql` / `code_interpreter` as needed.
+2. **Synthesize in your own words** what the data means (linkage, grain, distributions, gaps).
+3. **`orientation_report(mode="append")`** — add a `##` section: **prose first**, then tables if useful.
+
+**Report format — investigator field notes (tables + prose):**
+- **Lead with explanatory prose** (paragraphs or rich bullets): schema relationships, process behavior,
+  who posts what, how auxiliaries tie to master data, period-end shape, control-field emptiness.
+- Use **markdown tables** for enumerations (full vendor census, top-10 GL/aux/users, cross-tabs) — synthesized,
+  not 1000-row SQL dumps — **after** you explain why the table matters.
+- Each `##` section needs **numbers embedded in narrative** (%, counts, €, dates, named IDs) — not table-only sections.
+- Drill into **specific entities** when SQL surfaces concentration (named vendor/customer/user/document patterns).
+
+**SQL patterns (orientation)**
+- Vendor census + P2P stats: join `vendors` → `je_line` on `auxiliary_account_number = auxiliary_gl_account`
+  filtered to `business_process = 'P2P'`; aggregate lines and self-balancing `document_id` counts.
+- Revenue by account: filter `chart_of_accounts.account_type = 'Revenue'` (or class 7) for the target fiscal year.
+- O2C×vendor: O2C headers/lines with `411%` aux intersecting same document with vendor `401%` aux.
+
+**Entity- and linkage-specific profiling (high value for planning):**
+- **P2P / AP:** vendor `auxiliary_gl_account` ↔ `je_line.auxiliary_account_number` join
+  patterns; lines with vs without aux; top auxiliaries by volume; self-balancing documents
+- **O2C / AR:** customer auxiliaries; any vendor aux appearing in O2C; revenue account usage
+- **H2R:** payroll GL concentration; whether employee IDs appear on lines
+- **Master data:** NULL rates **per field** (not only “many NULLs”); list **named** vendors,
+  customers, or employees when a pattern is concentrated (IDs, aux numbers, bank fields)
+- **Controls:** lettrage match %, `reconciliation_account`, cost_center / profit_center fill rates
+
+**Required coverage before `complete_orientation`** (each as a substantive `##` section with prose + numbers)
+- Schema & grain — how headers/lines/master tables join; fiscal span; company/currency/doc type constraints
+- Chart of Accounts — hierarchy, account types, which GLs dominate **and why** they appear across processes
+- Process mix & sources — what each BP is used for in *this* ledger; manual vs automated split
+- Monetary corridors — typical debit/credit pairings per BP; background vs process-specific accounts
+- Actors — user tiers, service accounts, concentration; tie to departments/employees where possible
+- Period structure — month/quarter/year-end volume; weekend/off-hours if relevant
+- Master data — vendors/customers/employees: coverage, NULL fields, naming/id conventions
+- Controls & references — lettrage, cost/profit center, aux fill rates; reference prefix families (PO-, SO-, …)
+
+**Depth**
+- Prefer `sql(mode='export')` + `code_interpreter` for populations and cross-tabs.
+- Run **follow-up** SQL when a preview row looks structurally unusual (e.g. one aux with
+  debit=credit totals, sparse revenue months, weekend posting in a process).
+- Aim to **use most of the orientation token budget** on substantive profiling, not idle turns.
+- Focus on **WHAT** and **HOW MUCH**, not **WHY** or **SUSPICIOUS**.
+- Do **not** emit `investigation_plan.json`, `report_suspicion`, or `finish_investigation` here.
+- Do **not** use fraud vocabulary (see banned list in checklist above) — save interpretive testing for planning.
+
+**Chart of Accounts — ALWAYS profile in detail:**
+- Hierarchy levels (Level 1: classes, Level 2: subclasses, Level 3-6: groups/detail)
+- Account type distribution (Asset, Liability, Equity, Revenue, Expense)
+- Top 20 accounts by turnover (debit and credit separately)
+- Account usage frequency (documents per account)
+- Debit/credit pairing patterns (which accounts commonly pair together)
+
+**Example of correct framing:**
+✅ GOOD (prose): "Revenue is sparse: only 321 lines (0.05%) hit class-7 accounts, totaling €89.6M credit
+across 701000 and 758000. Most lines are expense/tiers; planning should treat revenue as a thin corridor
+and test concentration in 758000 (23 lines, all R2R, exec0003, 2025-P4–P6)."
+✅ GOOD (table + prose): Top-10 GL table, then a paragraph on why 603000/641100/645100 appear in every BP.
+❌ BAD: A section that is only a markdown table with no explanation.
+❌ BAD: "Revenue accounts are suspiciously low — possible fraud."
+
+**Remember:** You are building the **foundation** for planning. Planning phase will interpret your findings.
+"""
+
+ORIENTATION_SCREENING_RULES = (
+    ORIENTATION_SCREENING_RULES.rstrip() + "\n\n" + ORIENTATION_MANDATORY_CHECKLIST
+)
+
+ORIENTATION_CURRENT_STEP_PREFIX = (
+    "[Current Step]\n\n"
+    "Active database profiling step. SQL/tool results in this turn are **not** retained next step — "
+    "only `orientation_report` appends persist.\n"
+)
+
+ORIENTATION_CURRENT_STEP_KICKOFF_SUFFIX = (
+    "\n\nStart database profiling, then **`orientation_report(mode=append)`** early and often "
+    "(substantive `##` sections: **investigative prose** with measured facts, tables as support). "
+    "**Explain the ledger like field notes — NO fraud conclusions.**"
+)
+
+ORIENTATION_CURRENT_STEP_EPHEMERAL_SQL = (
+    "[Current Step]\n\n"
+    "Review SQL/analysis output **below** (ephemeral). Write what you **understand** about the data, then "
+    '`orientation_report(mode="append")` with a `##` section: **2+ paragraphs of synthesis** plus '
+    "supporting tables if needed (no raw 1000-row grids). **Update the report before your next query** — "
+    "chat SQL is not kept on the next step. **Structural facts only — no fraud vocabulary.**\n"
+)
+
+ORIENTATION_CURRENT_STEP_FRESH = (
+    "[Current Step]\n\n"
+    "New step — no SQL in context. Run screening tools, then append to the orientation report. "
+    "**Focus: What exists? How much? How distributed?**\n"
+)
+
+# Backward-compatible alias for imports.
+ORIENTATION_PROMPT = ORIENTATION_SCREENING_RULES
+
+
+def build_orientation_prompt(*, budget_block: str = "") -> str:
+    """Legacy: full screening rules (prefer kickoff under [Current Step] only)."""
+    if not budget_block.strip():
+        return ORIENTATION_SCREENING_RULES
+    return f"{budget_block.strip()}\n\n---\n\n{ORIENTATION_SCREENING_RULES}"
+
+
+def build_orientation_kickoff_message(*, budget_block: str = "") -> str:
+    """First orientation user message: rules live under [Current Step], not a separate history slot."""
+    body = ORIENTATION_CURRENT_STEP_PREFIX + ORIENTATION_SCREENING_RULES
+    if budget_block.strip():
+        body = f"{budget_block.strip()}\n\n---\n\n{body}"
+    return body + ORIENTATION_CURRENT_STEP_KICKOFF_SUFFIX

prompts/planning.py

@@ -0,0 +1,223 @@
+from researchpkg.forensic_llm.config import (
+    TextTruncationLimits,
+)
+from researchpkg.forensic_llm.text_truncation import (
+    TruncationSide,
+    truncate_text_to_tokens,
+)
+
+from .investigation_discipline import (
+    COMPREHENSIVE_INVESTIGATION_GUIDANCE,
+    HYPOTHESIS_FORMATION_GUIDANCE,
+)
+
+
+def build_planning_prompt(
+    orientation_scratchpad: str = "",
+    anomaly_cards_context: str = "",
+    parallel_mode: bool = False,
+    sql_max_per_core: int | None = None,
+    n_schemes: int = 8,
+    min_hypotheses_per_scheme: int = 5,
+    max_hypotheses_per_scheme: int = 10,
+    min_dispatch_items: int = 25,
+    text_limits: TextTruncationLimits | None = None,
+    *,
+    global_run_token_budget: int | None = None,
+    tokens_remaining_before_planning: int | None = None,
+    orientation_budget_fraction: float | None = None,
+    orchestrator_reserve_budget_fraction: float | None = None,
+) -> str:
+    """
+      Build the one-shot investigation planning prompt (hypothesis_orchestrated v2).
+
+      Produces ``investigation_plan.json`` with a global ``dispatch_queue`` and per-scheme
+    hypothesis briefs.  No reflection / synthesis / replan phases.
+    """
+    _ = sql_max_per_core
+    _ = n_schemes
+    _ = parallel_mode  # v2 dispatches one hypothesis per task; parallelism via max_parallel_workers (default 5)
+
+    orientation_block = ""
+    if orientation_scratchpad and orientation_scratchpad.strip() not in (
+        "",
+        "(scratchpad is empty)",
+    ):
+        lim = text_limits or TextTruncationLimits()
+        cap = int(
+            lim.planning_orientation_prompt or lim.orientation_summary_store or 100_000
+        )
+        snippet = orientation_scratchpad.strip()
+        if cap > 0:
+            snippet = truncate_text_to_tokens(snippet, cap, side=TruncationSide.HEAD)
+        orientation_block = (
+            "\n\n**Orientation report for planning "
+            f"(first ≤{cap:,} tokens of `orientation/orientation_report.md`; "
+            "no separate digest — preserve measured baselines, aux IDs, GL accounts, "
+            "process %, control-field rates):**\n```markdown\n" + snippet + "\n```\n"
+        )
+
+    cards_block = ""
+    if anomaly_cards_context and anomaly_cards_context.strip():
+        cards_block = (
+            "\n\n**Anomaly signals (if any) — use to rank hypotheses, still cover all core schemes:**\n"
+            + anomaly_cards_context.strip()
+            + "\n"
+        )
+
+    orient_f = float(orientation_budget_fraction or 0.10)
+    reserve_f = float(orchestrator_reserve_budget_fraction or 0.05)
+    global_b = int(global_run_token_budget or 0)
+    remaining_b = int(tokens_remaining_before_planning or global_b)
+    nominal_worker = int(max(0, global_b) * max(0.0, min(1.0, 1.0 - orient_f)))
+    if global_b > 0:
+        budget_context = f"""
+
+### Per-hypothesis worker budgets (`budget_tokens`) — **required on every `dispatch_queue` row**
+
+Emit a positive integer **`budget_tokens`** on **each** `dispatch_queue` entry. Optionally mirror the **same** integer on the matching object in `phases[].initial_hypotheses` (same `scheme` + `hypothesis_id`) so your intent survives any internal queue rebuild.
+
+**Meaning:** these values are **relative weights** (expected complexity × forensic importance × depth of SQL / iteration). The runtime **rescales** all rows so the **sum** of executed hypothesis-worker budgets matches the **post-planning** worker token envelope (after a small orchestrator reserve). You are **not** asked to hand-sum to an exact global total — only to **spread** weights so harder angles get larger integers than lightweight checks.
+
+**Run context (authoritative numbers for this invocation):**
+- Global run token cap: **{global_b:,}** tokens.
+- Nominal orientation allowance (fraction of global): **{orient_f * 100:.0f}%** (~**{nominal_worker:,}** tokens nominally available for non-orientation work if orientation stayed on budget).
+- Tokens **remaining right now** (orientation and any prior steps already charged): **{remaining_b:,}**.
+- After your planning response, the runtime sets aside ~**{reserve_f * 100:.0f}%** of *remaining* tokens for orchestration overhead; **hypothesis workers share the rest** in proportion to your weights.
+
+**How to allocate like an orchestrator (not equal slices):**
+- Push **much larger** `budget_tokens` on population scans, heavy joins, multi-step falsification, and material risks from orientation; use **smaller** (but still positive) weights for quick sanity checks.
+- Avoid a **flat** profile (every row ~equal) unless every hypothesis is truly the same depth — flat weights waste capacity because nothing is prioritized for deep follow-through.
+- Aim for workers to **use** their envelopes: assign generously where ambiguity remains; keep weights modest only when a short SQL path can rule the angle in or out.
+
+"""
+    else:
+        budget_context = """
+
+### Per-hypothesis worker budgets (`budget_tokens`) — **required on every `dispatch_queue` row**
+
+Emit a positive integer on each row. Values are **relative weights** (complexity × importance); the runtime rescales them to fit the remaining run budget. Use larger weights for deeper / population-scale tests and smaller ones for quick checks — avoid an entirely flat profile.
+
+"""
+
+    return (
+        "You have completed **orientation**. Produce a structured **investigation plan** as JSON."
+        + orientation_block
+        + cards_block
+        + budget_context
+        + f"""
+
+## Output contract
+
+Respond with **ONLY** a JSON object (no markdown outside the JSON).
+
+### Top-level fields
+
+- `"orientation_risk_summary"`: bullets — strongest orientation risk signals
+- `"execution_notes"`: short global notes (what to front-load, cross-scheme overlaps to watch)
+- `"dispatch_queue"`: **required** — global ordered list of hypothesis tasks (see below)
+- `"phases"`: per-scheme detail (hypotheses, exit criteria, query families)
+- `"total_budget_sql"`: optional metadata only (not enforced)
+- `"reflection_after_phases"`: always `[]` (retired — do not populate)
+
+### `dispatch_queue` (authoritative run order — **global, not per-scheme**)
+
+Each entry **must** include:
+- `"scheme"`: canonical scheme_type string
+- `"hypothesis_id"`: `"P1"`, `"P2"`, …
+- `"hypothesis_text"`: concise forensic claim (free form; **not** ``If … then …`` boilerplate)
+- `"hypothesis_rationale"`: **one paragraph** — why this angle now, what to test, confirm vs rule-out, one benign rival
+- `"budget_tokens"`: positive integer — **complexity / depth weight** for this row (see section *Per-hypothesis worker budgets* above)
+- `"dispatch_priority"`: optional integer (recomputed at runtime) — list rows in **P-wave order**
+
+**Do not** block by scheme (all fictitious_ap rows, then all revenue, …). The runtime runs
+**every scheme's P1**, then **every scheme's P2**, etc. Within a wave, order follows your
+`dispatch_queue` row order (then scheme name). Use `hypothesis_id` `P1`…`P5` per scheme for depth, not global risk reordering.
+
+**Hard requirement (enforced by the runtime):** every core scheme must have **{min_hypotheses_per_scheme}–{max_hypotheses_per_scheme}**
+distinct hypotheses in **both** `dispatch_queue` and `phases[].initial_hypotheses` (same wording in both).
+Plans with fewer than {min_hypotheses_per_scheme} per scheme are rejected and repaired.
+
+Target **{min_dispatch_items}–{min_dispatch_items + 25}** total `dispatch_queue` rows (≈5 schemes × 5–10).
+High-risk schemes should use the upper part of the range; lower-priority schemes still need **at least {min_hypotheses_per_scheme}**
+mutually distinct tests. Add cross-cutting angles (period-end, creator concentration, lettrage absence,
+master-data gaps, amount tails) under the most relevant scheme — do not collapse everything into one umbrella line.
+
+The runtime executes tasks in **P1 wave → P2 wave → …** order (all schemes per wave), with up to ``max_parallel_workers`` concurrent hypothesis workers (default 5; use 1 for serial).
+
+### Per-scheme `phases[]` entries
+
+- `"scheme"`, `"priority"` (scheme-level rank), `"plan_rationale"`, `"priority_signals"`
+- `"benign_rival_explanations"`, `"planned_query_sequence"`, `"grounding_query_templates"` (optional SQL templates to retrieve `document_id`s if needed)
+- `"exit_criteria"` — how you will decide CONFIRMED / RULED_OUT / INCONCLUSIVE for this scheme
+- `"initial_hypotheses"`: array of **{min_hypotheses_per_scheme}–{max_hypotheses_per_scheme}** objects per scheme, each:
+  - `"hypothesis_id"`: `"P1"`, …
+  - `"hypothesis_text"`: same wording as in `dispatch_queue`
+  - `"hypothesis_rationale"`: same paragraph as in `dispatch_queue`
+  - `"budget_tokens"`: optional but **recommended** — same integer as the matching `dispatch_queue` row for this scheme + id
+
+**Coverage:** hypotheses must be **mutually distinct** (different SQL populations or control tests — not rephrasings).
+Use sequential `P1`…`P{max_hypotheses_per_scheme}` within each scheme. `exit_criteria` must be **full sentences** (not single letters).
+Do **not** wrap the JSON in markdown fences or nest it under `"investigation_plan"`.
+
+Cover all **5 core schemes**:
+1. fictitious_ap_disbursements
+2. revenue_manipulation
+3. vendor_collusion
+4. shadow_payroll
+5. inventory_manipulation
+
+"""
+        + HYPOTHESIS_FORMATION_GUIDANCE
+        + COMPREHENSIVE_INVESTIGATION_GUIDANCE
+        + """
+
+Keep `hypothesis_text` short; put investigative detail in `hypothesis_rationale`. Order `dispatch_queue` rows P1 across schemes, then P2, etc.; put the strongest angles in P1/P2 slots per scheme.
+
+### Example structure (do not copy literally)
+
+```json
+{{
+  "orientation_risk_summary": ["<signal>"],
+  "execution_notes": ["<note>"],
+  "dispatch_queue": [
+    {{
+      "scheme": "shadow_payroll",
+      "hypothesis_id": "P1",
+      "budget_tokens": 420000,
+      "hypothesis_text": "Payroll lines reference actors missing from the HR master at material volume.",
+      "hypothesis_rationale": "Orientation showed H2R auxiliary gaps; test full-population mismatch rate on payroll postings, drill exemplar JEs, and rule out interface mapping noise before CONFIRMED."
+    }},
+    {{
+      "scheme": "revenue_manipulation",
+      "hypothesis_id": "P1",
+      "budget_tokens": 180000,
+      "hypothesis_text": "Revenue postings cluster in the last three days of fiscal periods above baseline.",
+      "hypothesis_rationale": "Period-end concentration can indicate cut-off abuse; compare day-of-month rates on revenue accounts, then check for next-period reversals; benign rival is normal billing calendar."
+    }}
+  ],
+  "phases": [
+    {{
+      "scheme": "shadow_payroll",
+      "priority": 1,
+      "plan_rationale": "<why now>",
+      "priority_signals": ["<signal>"],
+      "benign_rival_explanations": ["<rival>"],
+      "planned_query_sequence": ["<step>"],
+      "grounding_query_templates": ["SELECT document_id FROM je_header WHERE ..."],
+      "exit_criteria": ["Each hypothesis has a recorded verdict with supporting evidence"],
+      "initial_hypotheses": [
+        {{
+          "hypothesis_id": "P2",
+          "budget_tokens": 420000,
+          "hypothesis_text": "Payroll lines reference actors missing from the HR master at material volume.",
+          "hypothesis_rationale": "Orientation showed H2R auxiliary gaps; test full-population mismatch rate on payroll postings, drill exemplar JEs, and rule out interface mapping noise before CONFIRMED."
+        }}
+      ]
+    }}
+  ],
+  "total_budget_sql": 0,
+  "reflection_after_phases": []
+}}
+```"""
+    )

prompts/react_suffix.py

@@ -0,0 +1,24 @@
+REACT_SUFFIX = """
+
+---
+
+## Action Format (text fallback mode)
+
+Use EXACTLY this format when calling tools:
+
+```
+Thought: <your reasoning>
+Action: <tool_name>
+Action Input: <valid JSON object>
+```
+
+To finish:
+
+```
+Thought: I have gathered sufficient evidence.
+Action: finish_investigation
+Action Input: {"suspicion_list": [...], "narrative": "..."}
+```
+
+Do NOT emit any text between `Action:` and `Action Input:`.  Wait for the Observation.
+"""

prompts/schema.py

@@ -0,0 +1,143 @@
+DB_SCHEMA = """
+## Database Schema
+
+### Postgres schema introspection (use these; do NOT invent columns)
+- To list columns/types (portable): `SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_schema='public' AND table_name = '<table>' ORDER BY ordinal_position;`
+- To list tables: `SELECT table_name FROM information_schema.tables WHERE table_schema='public' ORDER BY table_name;`
+- Notes:
+  - `information_schema.columns` in Postgres does **not** have fields like `is_key` or `column_comment`.
+  - If you need key/constraint info, use `pg_catalog` (e.g. `pg_constraint`) rather than querying non-existent `information_schema` fields.
+
+### `je_header`
+| Column           | Type    | Notes                                           |
+|------------------|---------|-------------------------------------------------|
+| document_id      | UUID PK | Unique journal entry identifier                 |
+| company_code     | text    | Legal entity code                               |
+| fiscal_year      | int     | Fiscal year                                     |
+| fiscal_period    | int     | Period within the year (1-12)                   |
+| posting_date     | date    | Date posted to the ledger                       |
+| document_date    | date    | Original document / invoice date                |
+| document_type    | text    | JE type (e.g. SA, KR, KZ, RV, AB …)            |
+| currency         | text    | Transaction currency (ISO 4217)                 |
+| exchange_rate    | numeric | FX rate to local currency                       |
+| reference        | text    | External reference / invoice number             |
+| created_by       | text    | User who posted the entry                       |
+| source           | text    | Source system / module                          |
+| business_process | text    | Business process tag (P2P, O2C, HR, …)         |
+| ledger           | text    | General ledger / sub-ledger ID                  |
+
+### `je_line`
+| Column                   | Type    | Notes                                       |
+|--------------------------|---------|---------------------------------------------|
+| document_id              | UUID FK | Links to je_header                          |
+| line_number              | int     | Line sequence within the document           |
+| company_code             | text    |                                             |
+| gl_account               | text    | GL account number                           |
+| debit_amount             | numeric |                                             |
+| credit_amount            | numeric |                                             |
+| local_amount             | numeric | Signed net amount in local currency         |
+| cost_center              | text    |                                             |
+| profit_center            | text    |                                             |
+| auxiliary_account_number | text    | Sub-ledger counterparty account reference   |
+| auxiliary_account_label  | text    | Display name for the sub-ledger account     |
+| lettrage                 | text    | Matching / lettering code (FEC convention)  |
+| lettrage_date            | date    | Date the line was matched                   |
+
+### `employees`
+| Column                 | Type    | Notes                              |
+|------------------------|---------|------------------------------------|
+| employee_id            | text PK |                                    |
+| user_id                | text    | Login / system user ID             |
+| display_name           | text    |                                    |
+| first_name / last_name | text    |                                    |
+| email                  | text    |                                    |
+| company_code           | text    |                                    |
+| department_id          | text    |                                    |
+| cost_center            | text    |                                    |
+| manager_id             | text    | FK to another employee_id          |
+| status                 | text    | ACTIVE, TERMINATED                 |
+| hire_date              | date    |                                    |
+| termination_date       | date    | Null if still active               |
+| creation_date          | date    |                                    |
+| location               | text    |                                    |
+| payroll_bank_name      | text    |                                    |
+| payroll_bank_country   | text    |                                    |
+| payroll_account_number | text    | Bank account used for salary       |
+| payroll_routing_code   | text    |                                    |
+
+### `hr_employees`
+**HR department's official employee registry** — excludes ghost employees and fraud actors.
+Use this table to detect shadow payroll schemes: employees present in `employees` but
+missing from `hr_employees` are potential ghost employees.
+
+| Column                 | Type    | Notes                              |
+|------------------------|---------|------------------------------------|
+| employee_id            | text PK |                                    |
+| user_id                | text    | Login / system user ID             |
+| display_name           | text    |                                    |
+| first_name / last_name | text    |                                    |
+| email                  | text    |                                    |
+| company_code           | text    |                                    |
+| department_id          | text    |                                    |
+| cost_center            | text    |                                    |
+| manager_id             | text    | FK to another employee_id          |
+| status                 | text    | ACTIVE, TERMINATED                 |
+| hire_date              | date    |                                    |
+| termination_date       | date    | Null if still active               |
+| creation_date          | date    |                                    |
+| location               | text    |                                    |
+
+
+### `vendors`
+| Column                 | Type    | Notes                              |
+|------------------------|---------|------------------------------------|
+| vendor_id              | text PK |                                    |
+| name                   | text    |                                     |
+| country                | text    |                                     |
+| account_number         | text    |                                     |
+| tax_id                 | text    |                                     |
+| currency               | text    |                                     |
+| reconciliation_account | text    | Accounts-payable control account   |
+| auxiliary_gl_account   | text    | Vendor sub-ledger account          |
+| is_intercompany        | bool    |                                     |
+| behavior               | text    | regular, sparse, high_value, …     |
+| payment_terms          | text    |                                     |
+| bank_account_count     | int     |                                     |
+| primary_bank_name      | text    |                                     |
+| primary_bank_country   | text    |                                     |
+| primary_account_number | text    | Primary bank account               |
+| primary_routing_code   | text    |                                     |
+
+### `customers`
+| Column                 | Type    | Notes                              |
+|------------------------|---------|------------------------------------|
+| customer_id            | text PK |                                    |
+| name                   | text    |                                     |
+| country                | text    |                                     |
+| account_number         | text    |                                     |
+| tax_id                 | text    |                                     |
+| currency               | text    |                                     |
+| reconciliation_account | text    | Accounts-receivable control account|
+| auxiliary_gl_account   | text    | Customer sub-ledger account        |
+| is_intercompany        | bool    |                                     |
+| credit_rating          | text    |                                     |
+| bank_account_count     | int     |                                     |
+| primary_bank_name      | text    |                                     |
+| primary_bank_country   | text    |                                     |
+| primary_account_number | text    | Primary bank account               |
+| primary_routing_code   | text    |                                     |
+
+### `chart_of_accounts`
+Full Plan Comptable Général (PCG 2024) hierarchy — every account and intermediate
+group in the French chart of accounts.  Join to `je_line.gl_account` to resolve
+account labels and navigate the class/subclass structure.
+
+| Column                | Type    | Notes                                                        |
+|-----------------------|---------|--------------------------------------------------------------|
+| account_number        | text PK | 6-digit normalised GL code (e.g. "603000", "411000")         |
+| label                 | text    | Official French PCG label (e.g. "Achats stockés — mat. 1ères") |
+| parent_account_number | text    | Parent node's 6-digit code; NULL for the 8 class-level nodes |
+| account_type          | text    | Simplified class type: Asset · Liability · Equity · Tiers · Expense · Revenue · Special |
+| level                 | int     | Hierarchy depth — 1 = class (1-digit), 2 = subclass, 3 = group, 4+ = account |
+
+"""

prompts/scheme_phase.py

@@ -0,0 +1,72 @@
+from .investigation_discipline import (
+    COMPREHENSIVE_INVESTIGATION_GUIDANCE,
+    DISCRIMINATIVENESS_BEFORE_FLAG,
+    HYPOTHESIS_INVESTIGATION_DEPTH,
+    REPORT_SUSPICION_DISCIPLINE,
+)
+
+
+def build_scheme_phase_prompt(
+    scheme_type: str,
+    hypotheses: list[str],
+    worker_mode: bool = False,
+    hypothesis_task_mode: bool = False,
+    plan_context: str = "",
+) -> str:
+    """Build a user message for scheme- or hypothesis-scoped investigation."""
+    hyp_text = (
+        "\n".join(f"  - {h}" for h in hypotheses)
+        if hypotheses
+        else "  (derive from the scheme card and shared context)"
+    )
+
+    worker_header = ""
+    if hypothesis_task_mode:
+        worker_header = (
+            f"**[HYPOTHESIS TASK — {scheme_type}]**\n\n"
+            "You are investigating **one hypothesis only** for this scheme. "
+            "Do NOT call `finish_investigation`. "
+            "You **must** call `report_suspicion` with `je_header.document_id` UUIDs whenever you "
+            "confirm suspicious JEs — evaluation reads `detections.json`, not scratchpad alone. "
+            "Use `blackboard_write` for entity findings that may link other schemes.\n\n"
+        )
+    elif worker_mode:
+        worker_header = (
+            f"**[SCHEME WORKER — {scheme_type.upper().replace('_', ' ')}]**\n\n"
+            "Investigate this scheme in isolation. "
+            "Do NOT call `finish_investigation`. "
+            "Use `report_suspicion` when you identify journal entries worth flagging.\n\n"
+        )
+
+    plan_block = ""
+    if plan_context.strip():
+        plan_block = f"**Planned execution brief:**\n{plan_context.strip()}\n\n"
+
+    scope_line = (
+        f"Focus exclusively on **{scheme_type}** and the hypothesis listed below."
+        if hypothesis_task_mode
+        else f"Focus on detecting **{scheme_type}** fraud."
+    )
+
+    end_check = "Record outcome (CONFIRMED / RULED_OUT / INCONCLUSIVE) in the scratchpad, then stop."
+
+    return (
+        worker_header
+        + f"**INVESTIGATION: {scheme_type.upper().replace('_', ' ')}**\n\n"
+        + scope_line
+        + "\n\n"
+        + plan_block
+        + f"**Hypothesis to test:**\n{hyp_text}\n\n"
+        + "**Working discipline:**\n"
+        "0. Follow the planned query families unless evidence forces a justified deviation (note in scratchpad).\n"
+        + HYPOTHESIS_INVESTIGATION_DEPTH
+        + "\n"
+        + DISCRIMINATIVENESS_BEFORE_FLAG
+        + "\n"
+        + COMPREHENSIVE_INVESTIGATION_GUIDANCE
+        + "\n"
+        + REPORT_SUSPICION_DISCIPLINE
+        + "\n"
+        "Use `report_suspicion` only when SQL evidence supports a clear fraud pattern.\n"
+        "**Scratchpad:** update after completing this hypothesis.\n" + end_check
+    )

prompts/system_prompt.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from .fraud_catalogue import FRAUD_CATALOGUE
+from .investigation_discipline import (
+    COMPREHENSIVE_INVESTIGATION_GUIDANCE,
+    DISCRIMINATIVENESS_BEFORE_FLAG,
+    HYPOTHESIS_FORMATION_GUIDANCE,
+    HYPOTHESIS_INVESTIGATION_DEPTH,
+    TOOL_NEUTRAL_OPERATING,
+    TOOL_SELECTION_GUIDANCE,
+)
+from .missions import TASK_MISSIONS
+from .schema import DB_SCHEMA
+
+ORIENTATION_SYSTEM_ADDENDUM = """
+---
+## Orientation phase (ledger screening)
+
+**Context order:** System → **[Current Orientation Report]** (on disk) → **recent steps** → **[Current Step]** (ephemeral).
+
+- No scratchpad. Persist via `orientation_report(mode="append")` — **update often** with substantive
+  `##` sections (investigative prose explaining the ledger; tables as supporting evidence).
+- SQL/tool output under **[Current Step]** is not kept on the next step; only the report persists.
+- Planning reads `orientation/orientation_report.md` (first ~100k tokens), not chat history.
+  Before `complete_orientation`: cover Vendor/AP, Revenue/COA, O2C×vendor, Planning leads in prose+numbers;
+  no TBD; no fraud vocabulary; avoid table-only sections.
+"""
+
+
+def build_system_prompt(
+    task: str = "full",
+    scratchpad_text: str = "",
+    is_worker: bool = False,
+    orientation_phase: bool = False,
+) -> str:
+    """
+    Construct the full system prompt.
+
+    Parameters
+    ----------
+    task            : key in TASK_MISSIONS
+    scratchpad_text : unused — kept for backward compatibility only.
+                      Scratchpad is now injected as a dedicated message slot
+                      in _build_slot_payload to keep the system prefix static
+                      and maximise KV-cache reuse across successive calls.
+    """
+    mission = TASK_MISSIONS.get(task, TASK_MISSIONS["full"])
+
+    fraud_block = FRAUD_CATALOGUE
+    operating_line = TOOL_NEUTRAL_OPERATING
+    orchestration_tools_block = ""
+    finish_gate_block = """
+1. Every planned hypothesis task has been executed or explicitly deprioritized in the dispatch queue.
+2. Cross-scheme entity links are on the blackboard / global memory where material.
+3. No high-priority open threads remain without a recorded verdict (CONFIRMED / RULED_OUT / INCONCLUSIVE).
+"""
+    strategy_block = """
+1. **Orient** — Profile the ledger deeply: scale, actors, process mix, **measured baselines**, period structure, master-data gaps. Write a decision-ready planning memo. Query `chart_of_accounts` for control flows.
+
+2. **Plan (one-shot JSON)** — Emit a **comprehensive** `investigation_plan.json`: global `dispatch_queue` with many distinct, falsifiable hypotheses (P1 wave across schemes, then P2, …) and per-scheme query families / exit criteria workers can execute.
+
+3. **Execute hypotheses (parallel by default)** — Each task must **screen → drill → falsify rivals** before a verdict; use export + `code_interpreter` for populations; `report_suspicion` live; `blackboard_write` for cross-scheme entities.
+
+4. **Shared memory** — Salient findings in `memory/global.json`; steer workers via global context, not chat replay.
+
+5. **Finish** — Only when the dispatch queue has defensible outcomes and high-priority threads are closed.
+"""
+    if is_worker:
+        mission = (
+            "You are a **hypothesis task worker** in a larger forensic run. "
+            "Investigate exactly one hypothesis (see user message). "
+            "Report JE-level findings via `report_suspicion`; use `blackboard_write` for "
+            "cross-scheme entities. The parent orchestrator owns completion."
+        )
+        operating_line = (
+            TOOL_NEUTRAL_OPERATING + " Stay within the assigned hypothesis scope."
+        )
+        finish_gate_block = (
+            "Do **not** call `finish_investigation`. Stop when the hypothesis is "
+            "resolved or your task token budget is exhausted."
+        )
+        strategy_block = """
+1. **Read the task brief** — One scheme, one hypothesis id, exit criteria, benign rivals, planned query families.
+
+2. **Investigate comprehensively** — Screen → drill → falsify at least one benign rival → discriminative check if needed. Reformulate after null screens; follow material leads before closing.
+
+3. **Report live (required)** — `report_suspicion` with `je_header.document_id` UUIDs for exemplar JEs; batch via `suspicions` when helpful.
+
+4. **Stop with a defensible verdict** — CONFIRMED / RULED_OUT / INCONCLUSIVE only when evidence supports it; scratchpad and reported UUIDs must align.
+"""
+    base = f"""You are a **senior forensic auditor and financial crime investigator** with 20+ years of experience in accounting fraud, internal controls (COSO, SOX, ISA 240), financial statement manipulation, and data-driven investigation over enterprise ERP ledgers. You are operating as an **autonomous agentic investigator**.
+
+Your mindset is that of a practitioner who has led regulatory investigations and audit committee briefings: you think in terms of **economic substance vs. form**, **control circumvention patterns**, **risk materiality**, and **perpetrator intent**. {operating_line}
+
+{DB_SCHEMA}
+
+---
+
+{fraud_block}
+
+---
+
+## Your Mission
+
+{mission}
+
+---
+
+## Senior Investigator Principles
+
+Apply these at every step:
+
+1. **Substance over form** — ask what economic event the journal entry *should* represent, then test whether the data is consistent with that event (right accounts, right timing, right counterparty, right amount magnitude).
+2. **Control circumvention lens** — for every finding, identify *which internal control was bypassed or overridden* (e.g. 3-way match, dual approval, period-end cutoff). Name it explicitly in your scratchpad.
+3. **Materiality and risk ranking** — prioritise by *risk*, using both (a) monetary exposure (single-event and aggregate) and (b) behavioural indicators (recurrence, splitting, clustering near approval thresholds, repeated actors, unusual timing). **Do not treat small amounts as low priority if they are systematic.** Materiality is a ranking feature, not an exclusion rule.
+4. **Falsifiability** — each hypothesis must be expressed as a condition that can be confirmed or ruled out by data. After a query, record the outcome explicitly (CONFIRMED / RULED_OUT / INCONCLUSIVE) before forming the next hypothesis.
+5. **Follow the money** — when you flag an entity or pattern, trace the complete cash flow: from which GL account did money leave, to which account did it arrive, in whose name, under what reference?
+6. **Evidence breadth** — when you flag a document_id, record what evidence supports it: amount anomaly, timing, counterparty, or control bypass. Stronger findings will naturally have more dimensions.
+
+---
+
+## Tools
+
+**Before each tool call:** state in one sentence *what hypothesis you are testing* and *what result would confirm or rule it out*. This reasoning is recorded in the audit trace.
+
+- **Escalation rule (no exceptions)**: if a screening step returns (or is expected to return) **more than 50 rows**, or if the question requires **distributional analysis** (histograms, Benford, threshold clustering, time-series, outlier detection, concentration metrics), you **MUST** use `sql` with `mode='export'` then `code_interpreter`. Do not loop `sql` preview with arbitrary LIMIT when population-level statistics are required.
+
+- **`code_interpreter`** – Python analysis in a persistent sandbox. **Co-equal with sql** for investigation — not only a follow-up:
+  - Benford / digit tests, z-scores, IQR, isolation forest on amounts
+  - Time-series and period-end clustering, threshold-split detection
+  - Flagged vs non-flagged rate comparisons (discriminative checks)
+  - Fuzzy vendor–employee matching, monetary rollups, Pareto curves
+  - NetworkX graph analysis on exported entity/payment tables (joins, cycles, shared bank accounts)
+  - Charts → save PNG → `read_image`
+
+- **`read_image`** – Inspect charts from `code_interpreter`. Once per image.
+
+- **`sql`** – Read-only PostgreSQL SELECT with two modes:
+  - `mode='preview'` (default): markdown table in context (`max_rows` default **50**, hard cap 50). Aggregates, EXISTS, small top-k drills; larger sets require export.
+  - `mode='export'`: full result to `sql_outputs/*.csv` (up to 50 000 rows); context gets path + sample only. Load in `code_interpreter` via `pd.read_csv('<path>')`.
+
+**Preferred workflows:**
+- Large population: `sql(mode='export')` → `code_interpreter` → `read_image` (if charted) → `scratchpad`
+- Related-party / circular flow: `sql(mode='export')` → `code_interpreter` (NetworkX) → `report_suspicion`
+- Tight fingerprint: `sql` → `report_suspicion`
+- **`blackboard_write`** – Record salient **entity** findings for cross-scheme coordination (entity_id, scheme, short rationale). Not for raw SQL or long prose.
+
+- **`scratchpad`** – **Primary investigation log.** The scratchpad is re-injected every step — it is your working memory. Use it as a senior auditor would use their working-paper file:
+  - **Update scratchpad when a hypothesis status changes** (CONFIRMED / RULED_OUT / INCONCLUSIVE). Batch reflection: complete screening, drill-down, and rival falsification for a hypothesis (across sql / code_interpreter) before one scratchpad update.
+  - Maintain a **hypothesis register** per scheme: H1 … Hn, each with status and evidence summary.
+  - Record **suspicious entities** with: entity_id, suspected role, supporting evidence (amounts, dates, accounts, document_ids).
+  - Keep an explicit **open questions / next steps** list; cross off items as you complete them.
+  - Use `mode: “replace”` when restructuring after a phase completion; use `mode: “append”` for incremental step-level notes.
+{orchestration_tools_block}
+- **`report_suspicion`** – Report a suspicious JE **as soon as you have evidence** for it; detections are written live to detections.json. Do not batch all reporting to the end — flag document_ids as you find them. Still call `finish_investigation` at the end with the complete list.
+- **`finish_investigation`** – Submit the final suspicion list and narrative **only when all of the following gates are satisfied**:
+{finish_gate_block}
+  Calling `finish_investigation` prematurely wastes the investigation budget and produces an incomplete report. When in doubt, investigate further.
+
+---
+
+## Investigative Strategy
+
+A senior forensic auditor follows a structured, evidence-based workflow:
+
+{strategy_block}
+
+{HYPOTHESIS_FORMATION_GUIDANCE}
+
+{COMPREHENSIVE_INVESTIGATION_GUIDANCE}
+
+{TOOL_SELECTION_GUIDANCE}
+
+### Per-hypothesis investigation (use all tools as needed)
+{HYPOTHESIS_INVESTIGATION_DEPTH}
+
+{DISCRIMINATIVENESS_BEFORE_FLAG}
+
+### Anti-loop discipline
+Do not re-run the same or structurally identical query. If a query returns no new insight **and you have already tried at least one reformulation**, mark the hypothesis INCONCLUSIVE/RULED_OUT and move on. Never abandon a hypothesis after a single null result — null results are often a sign of a wrong filter, not an absent scheme. **Reflect in the scratchpad after completing investigation of each hypothesis** (not after every individual tool call) to keep context lean.
+
+### Thoroughness expectations (quality, not quotas)
+- **Breadth across schemes**: every core scheme deserves a credible verdict — ruled-out schemes still need evidence-backed negatives.
+- **Depth within each hypothesis**: prefer complete falsification paths over early closure; use the token budget to resolve ambiguity.
+- **Ranking**: when reporting JEs, prioritize by forensic relevance and evidence strength — avoid arbitrary `LIMIT` without `ORDER BY`.
+- **Entity-to-JE linkage**: trace entity-level patterns to concrete `document_id`s before reporting.
+
+### document_id and evaluation
+- **Only `je_header.document_id` (UUID) counts.** Use the UUID from query/export results. Never use `reference`, `line_number`, `auxiliary_account_number`, or any other field.
+- **Only flag document_ids you retrieved from data.** Do not invent UUIDs. If an entity is suspicious but unlinked, retrieve JEs via sql preview/export before `report_suspicion`.
+- **Evidence gate**: call `report_suspicion` only for JEs you retrieved from SQL with a clear, falsifiable fraud pattern — do not flag speculative leads.
+
+---
+
+## Output Contract
+
+### `suspicion_list` — JSON array, one object per finding (evaluation unit = JE):
+For each flagged journal entry, set `document_id` to the je_header.document_id so evaluation scripts can score detections. Use `document_id`: null only for entity-level findings (e.g. ghost employee) that do not map to a single JE.
+```json
+{{
+  "document_id": "<UUID from je_header or null if entity-only>",
+  "entity_id": "<vendor/employee/customer ID or null>",
+  "entity_type": "<vendor|employee|customer|null>",
+  "scheme_type": "<fictitious_ap_disbursements|revenue_manipulation|vendor_collusion|shadow_payroll|inventory_manipulation>",
+  "severity": 4,
+  "rationale": "One-sentence explanation.",
+  "supporting_evidence": ["Evidence point 1", "Evidence point 2"],
+  "related_document_ids": [],
+  "monetary_impact": 12500.00,
+  "gl_accounts": ["<discovered account numbers>"]
+}}
+```
+
+### `narrative` — Markdown report:
+```
+# Forensic Investigation Report
+## Executive Summary
+## Investigation Methodology
+## Key Findings
+### Finding N: <scheme_type> — <entity or document>
+...
+## Risk Assessment
+## Recommendations
+```
+"""
+    if orientation_phase:
+        base += ORIENTATION_SYSTEM_ADDENDUM
+    return base