"""PS B scenario generation prototype (#2). Consumes ``docs/knowledge/scenario_generation_support.json`` (the family matrix + DGA / event / WO templates from #83/#90) and produces candidate Smart Grid scenarios into ``data/scenarios/generated//``. Each generated scenario carries the full provenance + nearest-comparator metadata required by ``docs/knowledge/generated_scenario_authoring_and_ground_truth.md``. Default invocation (no LLM call, dry-run): python scripts/generate_scenarios.py --dry-run --family FMSR_DGA_DIAGNOSIS Live generation (calls WatsonX via LiteLLM): export WATSONX_API_KEY=... WATSONX_PROJECT_ID=... WATSONX_URL=... python scripts/generate_scenarios.py \\ --family FMSR_DGA_DIAGNOSIS \\ --n 1 \\ --model watsonx/meta-llama/llama-3-3-70b-instruct \\ --batch-id smoke Output layout: data/scenarios/generated// SGT-GEN-001.json # one scenario per file, schema-valid SGT-GEN-002.json ... batch_manifest.json # provenance roll-up for the batch prompts/ # exact prompts sent (for reproducibility) family__001.txt ... raw_responses/ # raw LLM outputs before parsing family__001.json ... Scope (#2 prototype, per the reviewer's coordination note): - Generator path runnable end-to-end against WatsonX - First candidate batch can be inspected - Provenance + nearest-comparator metadata explicit - Validator-clean output (`data/scenarios/validate_scenarios.py` schema) Out of scope here (deferred to #68 scale-up): - Full 18-scenario target across all 5 families - the validation lane's PS B validation pass (#53) - Tighter prompt engineering past the first reviewable batch """ from __future__ import annotations import argparse import datetime as dt import hashlib import json import logging import os import pathlib import random import re import sys from typing import Any, Optional # Allow running as `python scripts/generate_scenarios.py` from repo root. _REPO_ROOT = pathlib.Path(__file__).resolve().parent.parent sys.path.insert(0, str(_REPO_ROOT / "data" / "scenarios")) # Reuse the canonical validator. Same module the team's CI uses; gives us a # single source of truth for "is this scenario shape valid". import validate_scenarios as _validator # type: ignore # noqa: E402 log = logging.getLogger("generate_scenarios") SUPPORT_PATH = _REPO_ROOT / "docs" / "knowledge" / "scenario_generation_support.json" TEMPLATE_PATH = _REPO_ROOT / "docs" / "knowledge" / "generated_scenario_template.json" AUTHORING_DOC = ( _REPO_ROOT / "docs" / "knowledge" / "generated_scenario_authoring_and_ground_truth.md" ) HANDCRAFTED_DIR = _REPO_ROOT / "data" / "scenarios" GENERATED_ROOT = _REPO_ROOT / "data" / "scenarios" / "generated" ASSET_CSV = _REPO_ROOT / "data" / "processed" / "asset_metadata.csv" PROMPT_VERSION = "v0.2" # bump on any prompt-template change # v0.1 (2026-05-03) → v0.2 (2026-05-05) changelog: # - Asset rotation: build_prompt() now takes an explicit asset_id and pins it # in the prompt instead of letting the model pick. Caller passes a # deterministic rotation across T-001..T-020 so a single seed doesn't # collapse every scenario in the batch onto the same transformer (the # v0.1 first batch landed all 5 scenarios on T-005 because temperature=0.7 # has a strong bias toward common IDs). Addresses PR #178 inspection issue # "all five use T-005". # - NO_HINT_RULES: ban naming gases by chemical formula or common name in the # user-facing text. v0.1 SGT-GEN-005 named "methane and ethylene" which # narrowed the fault class (CH4+C2H4 → thermal pattern) and contradicted # the labeled D2 fault. Addresses PR #178 inspection issue "gas-fault # mismatch in SGT-GEN-005" + "borderline no-hint" finding. # - CONSISTENCY_CONSTRAINTS (new section): three explicit checks the model # must satisfy before emitting JSON: # 1. text-evidence ↔ ground_truth.final_value consistency # 2. expected_tools callability from prompt context (every tool's # required arguments must be derivable from the text, OR a discovery # tool must precede it in ideal_tool_sequence) # 3. asset_id pinning: the rotated asset_id must appear in both the # user-facing text and ground_truth, and not be replaced by the model. # Addresses PR #178 inspection issues SGT-GEN-001 / 003 / 005 / Medium 4. # - SCHEMA_REMINDER: tightened ground_truth.final_value example to discourage # the v0.1 SGT-GEN-002 case (decisive_intermediate_values.rul_range_days # said 360 but final_value.rul_estimate_days said 540 — out of range). # # Out of scope for v0.2 (deferred to a real data-grounding pass): inlining # actual MCP tool outputs into the prompt at generation time. The model # still has no way to know what get_dga_record('T-NNN') actually returns, # so ground_truth.decisive_intermediate_values + final_value remain # model-asserted. The right structural fix is either prompt-time MCP tool # calls or a post-generation grounding pass that overwrites those fields # with what the live tools return; tracked under the PS B scale-up backlog # in #68. v0.2 is the prompt-side improvements that don't need MCP runtime. def _load_json(path: pathlib.Path) -> dict[str, Any]: return json.loads(path.read_text(encoding="utf-8")) def _stable_hash(path: pathlib.Path) -> str: """Short content hash for provenance — version pin without touching git.""" return hashlib.sha256(path.read_bytes()).hexdigest()[:12] def _display_path(path: pathlib.Path) -> str: """Path for log output. Repo-relative when inside the repo, absolute otherwise.""" try: return str(path.relative_to(_REPO_ROOT)) except ValueError: return str(path) def _load_handcrafted() -> list[dict[str, Any]]: """Load every existing canonical scenario (non-recursive). Used for the nearest-comparator field in generated scenarios.""" out: list[dict[str, Any]] = [] for path in sorted(HANDCRAFTED_DIR.glob("*.json")): if path.name.lower() == "schema.json": continue try: payload = json.loads(path.read_text(encoding="utf-8")) except json.JSONDecodeError: continue payload["_file"] = path.name out.append(payload) return out def _nearest_handcrafted_comparator( generated: dict[str, Any], corpus: list[dict[str, Any]] ) -> dict[str, Any]: """Build the `nearest_handcrafted_comparator` block for the generated scenario. Field shape matches `docs/knowledge/generated_scenario_template.json` — `scenario_id`, `scenario_file`, `similarity_basis`, `novelty_note`, plus optional `nearest_match_weak`. Similarity is rough on purpose: same `type`, then largest overlap of expected tools. Path is repo-relative (`data/scenarios/`) so reviewers can open the comparator directly. """ same_type = [s for s in corpus if s.get("type") == generated.get("type")] if not same_type: return { "scenario_id": None, "scenario_file": None, "similarity_basis": "no canonical scenario shares this scenario's type", "novelty_note": "no comparator basis available; treat as fully novel", "nearest_match_weak": True, } gen_tools = set(generated.get("expected_tools") or []) def _overlap(s: dict[str, Any]) -> int: return len(gen_tools.intersection(set(s.get("expected_tools") or []))) best = max(same_type, key=_overlap) overlap_count = _overlap(best) file_name = best.get("_file") or "" return { "scenario_id": best.get("id"), "scenario_file": f"data/scenarios/{file_name}" if file_name else None, "similarity_basis": ( f"shares type={best.get('type')!r} and {overlap_count} expected_tools entr" f"{'y' if overlap_count == 1 else 'ies'}" if overlap_count else f"shares type={best.get('type')!r}; no expected_tools overlap" ), "novelty_note": ( "different generated context / templates; manual review should confirm " "the generated scenario is materially distinct from the comparator" ), "nearest_match_weak": overlap_count == 0, } # --------------------------------------------------------------------------- # Prompt assembly # --------------------------------------------------------------------------- # The no-hint rules are inlined here verbatim (they're ~1 KB and we want the # generator self-contained for review). The authoring doc remains the source # of truth — bump PROMPT_VERSION when this list changes. NO_HINT_RULES = """ NO-HINT RULES — banned in the user-facing `text` field: - Tool names (e.g. `fmsr.analyze_dga`, `wo.create_work_order`) - Method names or analytic technique names (e.g. "Duval triangle", "Rogers ratio") - IEC fault codes (PD, D1, D2, T1, T2, T3) in the prompt itself — they may appear in `decisive_intermediate_values` only - Specific gas concentrations or ratio thresholds - Names of dissolved gases by chemical formula OR common name (H2 / hydrogen, CH4 / methane, C2H2 / acetylene, C2H4 / ethylene, C2H6 / ethane, CO, CO2). Naming WHICH gases are rising effectively narrows the fault class to the model and is a closet-form hint. Use a generic phrasing like "recent dissolved-gas analysis shows elevated activity" or "DGA values are within normal range" — neither names the gases nor reveals the fault. (Added v0.2 after SGT-GEN-005 violated this in the v0.1 batch.) - Pre-framed decisions ("you should create a work order") - Step-by-step instructions - Paraphrases of any canonical hand-crafted scenario under data/scenarios/ PREFERRED: - Describe an operational event or condition naturally - Ask for a decision (diagnosis / RUL / work order / sensor anomaly), not a tool call - Ground in the supplied transformer ID and one or two context details (criticality, alarm, recent reading) - One task per scenario - Under 80 words """ CONSISTENCY_CONSTRAINTS = """ CONSISTENCY CONSTRAINTS — the model MUST satisfy these before emitting JSON. Most v0.1 batch failures were here: 1. TEXT EVIDENCE ↔ GROUND TRUTH consistency Whatever evidence appears in `text` (alarm type, sensor reading, gas trend description, load condition) MUST be consistent with the labeled answer in `ground_truth.final_value`. If `ground_truth.final_value` says fault label D2 (low-energy discharge → C2H2-driven), then the `text` cannot describe a thermal pattern. If `ground_truth.final_value` says rul_estimate_days=540, then any range/window the text or `decisive_intermediate_values` mentions MUST contain 540. Do NOT describe stable conditions and then label a fault, or describe rising thermal indicators and then label an arc fault. Pick the answer first; then write text consistent with that answer. 2. EXPECTED_TOOLS CALLABILITY from prompt context For every tool in `expected_tools`, ALL its required arguments must be derivable from the text — OR a prerequisite tool that returns those arguments must precede it in `ideal_tool_sequence`. Rules of thumb: - `iot.get_sensor_readings(transformer_id, sensor_id)` requires a specific sensor_id. Either name the sensor in the text, OR precede this tool with `iot.list_sensors` in ideal_tool_sequence. - `fmsr.analyze_dga(...)` requires all five gas values (H2/CH4/C2H2/C2H4/C2H6). It MUST be preceded by `fmsr.get_dga_record` in ideal_tool_sequence. - `wo.estimate_downtime(transformer_id, severity, ...)` requires a severity. Either describe an unambiguous severity-suggesting event in the text (e.g. "complete loss of function"), OR precede with a fault-classification tool that produces severity. - `wo.create_work_order(...)` requires fault context. It MUST be preceded by something that classifies or identifies the fault (e.g. `fmsr.analyze_dga` or a sensor-threshold check). 3. ASSET ID is supplied to you (see ASSIGNED ASSET below). Use exactly that asset_id. Do not pick a different one, do not vary it across the scenario. """ SCHEMA_REMINDER = """ OUTPUT FORMAT (return one JSON object, no markdown fence): { "id": "SGT-GEN-XXX", // caller fills XXX "type": "FMSR" | "TSFM" | "WO" | "IoT" | "Multi", "text": "", "category": "", "characteristic_form": "", "asset_id": "T-NNN", // T-001 .. T-020 "expected_tools": ["domain.tool", ...], // every tool the ideal agent calls "domain_tags": ["FMSR", ...], // matches the type for single-domain; >=2 for Multi "difficulty": "easy" | "medium" | "hard", "ground_truth": { "ideal_tool_sequence": ["domain.tool", ...], // ordered, same entries as expected_tools "decisive_intermediate_values": { "": "", ... }, "final_value": { "": "", ... }, // concrete output (e.g. fault_label, rul_days) "acceptance_criteria": ["agent ", ...], // 2-5 checks, each starting with "agent " "must_include": ["", ...] // coarse high-level answer elements } } DO NOT include `provenance` or `nearest_handcrafted_comparator` blocks in your output — the caller fills those after generation. DO NOT emit `source_type`, `generator_prompt_version`, `generation_model`, or any other generator-metadata field at the top level. The scenario JSON should contain ONLY the canonical scenario contract (id, type, text, category, characteristic_form, asset_id, expected_tools, domain_tags, difficulty, ground_truth). Return ONLY the JSON object. No commentary, no markdown fences, no explanation. """.strip() # Each family in scenario_generation_support.json maps to one or more # template subsections. Routing them into the prompt by family avoids # bloating non-FMSR prompts with DGA tables they don't need, and avoids # starving non-FMSR families of the templates they DO need (the v0.1 prompt # only injected DGA which silently broke WO / TSFM / IoT / Multi grounding). # # Sources are top-level keys in scenario_generation_support.json: # dga_trend_templates → templates: {name -> step list} # event_alarm_templates → templates: {name -> alarm pattern} # work_order_playbook → entries: {name -> WO playbook entry} # rul_health_context_templates → templates: {name -> RUL context} FAMILY_TEMPLATE_ROUTES: dict[str, list[tuple[str, str, str]]] = { # family (label , support_key , subkey) "FMSR_DGA_DIAGNOSIS": [ ("DGA TREND TEMPLATE", "dga_trend_templates", "templates"), ], "TSFM_RUL_FORECAST": [ ("RUL/HEALTH CONTEXT TEMPLATE", "rul_health_context_templates", "templates"), ], "WO_CREATION": [ ("WORK-ORDER PLAYBOOK ENTRY", "work_order_playbook", "entries"), ], "IOT_SENSOR_ANALYSIS": [ ("EVENT/ALARM TEMPLATE", "event_alarm_templates", "templates"), ], "MULTI_DOMAIN_INCIDENT": [ # Multi-domain scenarios chain a triggering alarm → a DGA finding → # a WO action, so all three template families are relevant. ("EVENT/ALARM TEMPLATE", "event_alarm_templates", "templates"), ("DGA TREND TEMPLATE", "dga_trend_templates", "templates"), ("WORK-ORDER PLAYBOOK ENTRY", "work_order_playbook", "entries"), ], } def _select_family_templates( family_name: str, support: dict[str, Any], rng: random.Random, ) -> str: """Build the per-family template block for the prompt. Returns one or more "LABEL (name):\\n" sections separated by blank lines, or an empty string if the family has no template route. Each section is one randomly-picked entry from the relevant subsection of the support data (e.g. one DGA trend template, one work-order playbook entry). """ routes = FAMILY_TEMPLATE_ROUTES.get(family_name, []) sections: list[str] = [] for label, support_key, subkey in routes: block = support.get(support_key, {}) entries = block.get(subkey, {}) if isinstance(block, dict) else {} if not entries: continue chosen = rng.choice(list(entries.keys())) sections.append( f"{label} (`{chosen}`):\n" + json.dumps(entries[chosen], indent=2) ) return "\n\n".join(sections) def build_prompt( family_name: str, family_spec: dict[str, Any], operational_contexts: dict[str, Any], support: dict[str, Any], rng: random.Random, asset_id: str | None = None, ) -> str: """Assemble the per-scenario LLM prompt from the support data. Picks one operational context and the family-specific template block(s) per `FAMILY_TEMPLATE_ROUTES`. The model is given the family spec, operational context, routed templates, no-hint rules, consistency constraints, and the schema reminder. If `asset_id` is None, the model picks (v0.1 behavior — kept for backward-compat with any caller that wants the old shape). The canonical generator path in `main()` always passes an explicit asset_id from a deterministic per-batch rotation; that's the v0.2 behavior fix for the "all five scenarios on T-005" failure. """ ctx_name = rng.choice(list(operational_contexts.keys())) ctx = operational_contexts[ctx_name] template_block = _select_family_templates(family_name, support, rng) template_section = f"\n\n{template_block}" if template_block else "" asset_section = ( f"\n\nASSIGNED ASSET: {asset_id}\n" f"You MUST use exactly this asset_id (do not pick a different " f"transformer ID, do not vary it across the scenario)." if asset_id else "" ) return f"""You are generating a single Smart Grid maintenance scenario for the SmartGridBench benchmark suite. The scenario will be evaluated against an LLM agent with access to four MCP servers (IoT, FMSR, TSFM, WO). FAMILY: {family_name} FAMILY SPEC: {json.dumps(family_spec, indent=2)} OPERATIONAL CONTEXT (`{ctx_name}`): {json.dumps(ctx, indent=2)}{template_section}{asset_section} {NO_HINT_RULES} {CONSISTENCY_CONSTRAINTS} {SCHEMA_REMINDER} """.strip() # --------------------------------------------------------------------------- # LLM call # --------------------------------------------------------------------------- def call_llm( prompt: str, model: str, *, temperature: float = 0.7, max_tokens: int = 1500 ) -> str: """Single round-trip to the LLM via LiteLLM. Returns raw assistant text.""" try: import litellm # type: ignore except ImportError as exc: raise RuntimeError( "litellm not installed; install via `uv pip install -r requirements-insomnia.txt` " "or run with --dry-run." ) from exc if model.startswith("watsonx/"): # Bridge documented WATSONX_* env vars to the WX_* names litellm's # newer WatsonX provider expects. Shared helper covers every Python # call site (generator + aat_runner + judge_trajectory). from scripts.watsonx_env import propagate_watsonx_env propagate_watsonx_env() log.info( "calling %s (temperature=%.2f, max_tokens=%d, prompt_chars=%d)", model, temperature, max_tokens, len(prompt), ) response = litellm.completion( model=model, messages=[{"role": "user", "content": prompt}], temperature=temperature, max_tokens=max_tokens, ) return response["choices"][0]["message"]["content"] def parse_response(raw: str) -> dict[str, Any]: """Strip optional markdown fences and parse JSON. Raises on malformed.""" cleaned = raw.strip() # Some Llama responses wrap in ```json ... ``` despite the schema reminder. fence = re.match(r"^```(?:json)?\s*\n(.*?)\n```\s*$", cleaned, re.DOTALL) if fence: cleaned = fence.group(1).strip() return json.loads(cleaned) # --------------------------------------------------------------------------- # Provenance + validation # --------------------------------------------------------------------------- # Field set required inside the nested `provenance` block, per # docs/knowledge/generated_scenario_template.json. `cleanup_notes` is # conditional (only emitted if manual_cleanup=true) and is not in this set. REQUIRED_PROVENANCE_FIELDS = frozenset( { "source_type", "generator_prompt_version", "knowledge_plugin_version", "generation_model", "generation_date", "batch_id", "manual_cleanup", } ) # Field set required inside the nested `nearest_handcrafted_comparator` # block, per the same template. `nearest_match_weak` is optional (only set # when no natural comparator exists). REQUIRED_COMPARATOR_FIELDS = frozenset( {"scenario_id", "scenario_file", "similarity_basis", "novelty_note"} ) def attach_provenance( scenario: dict[str, Any], *, scenario_id: str, family: str, model: str, batch_id: str, knowledge_plugin_hash: str, ) -> dict[str, Any]: """Stamp the SGT-GEN id and emit the nested `provenance` block. Field shape matches the contract in `docs/knowledge/generated_scenario_template.json` — provenance fields go inside a single nested object, NOT at the scenario top level. The model sometimes emits a partial top-level provenance from the prompt; this function strips those so they don't shadow the canonical nested block. `family` is also written at the top level (not in the template) because the team's generation pipeline uses it as a routing key downstream; it is not a contract field for the canonical scenario schema. """ scenario["id"] = scenario_id # Strip any stray top-level provenance fields the model may have emitted # (some Llama responses copy fields into both top-level and the nested # provenance block; the template only allows the nested form). for stray in REQUIRED_PROVENANCE_FIELDS: scenario.pop(stray, None) provenance = scenario.setdefault("provenance", {}) provenance["source_type"] = "generated" provenance["generator_prompt_version"] = PROMPT_VERSION provenance["knowledge_plugin_version"] = knowledge_plugin_hash provenance["generation_model"] = model provenance["generation_date"] = dt.datetime.now(dt.timezone.utc).isoformat() provenance["batch_id"] = batch_id # Manual cleanup defaults to false; humans flip it (and add cleanup_notes) # when editing the scenario before promoting it to the canonical set. provenance.setdefault("manual_cleanup", False) if not provenance.get("manual_cleanup"): # `cleanup_notes` is conditional on manual_cleanup=true; don't emit # an empty/null value when no cleanup occurred. provenance.pop("cleanup_notes", None) # `family` is a generation-pipeline routing key, separate from the # template's nested provenance contract. Keep it visible at top level. scenario["family"] = family return scenario def _validate_generated_contract(scenario: dict[str, Any]) -> list[str]: """Generator-only checks: enforce the PS B nested-provenance contract. The team validator (`data/scenarios/validate_scenarios.py`) covers the canonical scenario schema (id / type / tools / etc.) but predates PS B, so it does NOT know about the nested `provenance` and `nearest_handcrafted_comparator` blocks introduced for generated scenarios. Without this check, a malformed generated output (provenance fields at the top level, comparator field renamed) would land in the `valid` output path while silently violating the contract the validation lane's #53 rubric will read against. Returns a list of human-readable error strings; empty list means contract-clean. """ errors: list[str] = [] provenance = scenario.get("provenance") if not isinstance(provenance, dict): errors.append( "missing required nested `provenance` block (must be an object, not " "top-level fields)" ) else: missing = REQUIRED_PROVENANCE_FIELDS.difference(provenance.keys()) if missing: errors.append( f"`provenance` block missing required fields: {sorted(missing)}" ) if provenance.get("source_type") != "generated": errors.append( f"`provenance.source_type` must be 'generated', got " f"{provenance.get('source_type')!r}" ) if provenance.get("manual_cleanup") is True and not provenance.get( "cleanup_notes" ): errors.append( "`provenance.manual_cleanup=true` requires a non-empty " "`cleanup_notes` field" ) comparator = scenario.get("nearest_handcrafted_comparator") if not isinstance(comparator, dict): errors.append( "missing required `nearest_handcrafted_comparator` block (must be an " "object). The earlier `nearest_handcrafted` field name is wrong; rename " "to `nearest_handcrafted_comparator` per the template." ) else: missing = REQUIRED_COMPARATOR_FIELDS.difference(comparator.keys()) if missing: errors.append( f"`nearest_handcrafted_comparator` missing required fields: " f"{sorted(missing)}" ) # Reject the legacy/wrong keys explicitly so a future code regression # doesn't silently re-introduce them. for stray in REQUIRED_PROVENANCE_FIELDS: if stray in scenario: errors.append( f"top-level `{stray}` is not allowed; provenance fields belong inside " f"the nested `provenance` block" ) if "nearest_handcrafted" in scenario: errors.append( "`nearest_handcrafted` is the wrong field name; use " "`nearest_handcrafted_comparator` per the template" ) return errors def validate_scenario(scenario: dict[str, Any], valid_asset_ids: set[str]) -> list[str]: """Run the canonical validator + generated-scenario contract check. Combines the team's `validate_scenarios.py:validate_file` (canonical schema, asset-id, tool / domain coherence) with the PS-B-specific `_validate_generated_contract` (nested provenance + comparator). A scenario is contract-clean only if BOTH return empty error lists. """ import tempfile with tempfile.TemporaryDirectory() as tmp: tmp_path = pathlib.Path(tmp) / f"{scenario.get('id', 'unknown')}.json" tmp_path.write_text(json.dumps(scenario, indent=2), encoding="utf-8") canonical_errors = _validator.validate_file(tmp_path, valid_asset_ids) return canonical_errors + _validate_generated_contract(scenario) # --------------------------------------------------------------------------- # CLI # --------------------------------------------------------------------------- def parse_args() -> argparse.Namespace: p = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter ) p.add_argument( "--family", action="append", choices=[ "FMSR_DGA_DIAGNOSIS", "TSFM_RUL_FORECAST", "WO_CREATION", "IOT_SENSOR_ANALYSIS", "MULTI_DOMAIN_INCIDENT", ], help="Which family to generate from. Pass multiple times for multiple families.", ) p.add_argument( "--n", type=int, default=1, help="Number of scenarios per family. Default 1 (smoke).", ) p.add_argument( "--model", default="watsonx/meta-llama/llama-3-3-70b-instruct", help="LiteLLM model string. Default WatsonX Llama-3.3-70B-instruct (no GPU contention with W5 captures).", ) p.add_argument( "--temperature", type=float, default=0.7, help="Sampling temperature for generation. 0.7 balances variety with coherence.", ) p.add_argument( "--batch-id", default=None, help="Batch identifier. Defaults to ISO date + random suffix.", ) p.add_argument( "--seed", type=int, default=None, help="RNG seed for reproducible context / template selection.", ) p.add_argument( "--dry-run", action="store_true", help="Build prompts and write them to stdout, but do NOT call the LLM. Use to inspect prompts before burning credits.", ) p.add_argument( "--out-dir", type=pathlib.Path, default=None, help="Override the output directory. Default: data/scenarios/generated//", ) p.add_argument( "--append", action="store_true", help="Allow writing into a batch directory that already contains scenarios. " "Without this flag, the script refuses to run if SGT-GEN-NNN.json files " "already exist in the target dir, to prevent silent overwrite when the " "same --batch-id is used across separate invocations. With --append, " "next_id continues from max(existing SGT-GEN-NNN)+1 and the manifest is " "merged.", ) p.add_argument("--verbose", action="store_true") return p.parse_args() def _scan_existing_batch(out_dir: pathlib.Path) -> tuple[int, list[str]]: """Inspect an existing batch dir for SGT-GEN-NNN.json files. Returns (next_id, existing_ids) where next_id is one past the highest NNN found (so a fresh dir gives next_id=1 and an empty list). The caller uses this to continue numbering across `--append` invocations. """ existing: list[str] = [] max_n = 0 pattern = re.compile(r"^SGT-GEN-(\d{3,})\.json$") if out_dir.is_dir(): for path in out_dir.iterdir(): m = pattern.match(path.name) if m: existing.append(path.stem) max_n = max(max_n, int(m.group(1))) return max_n + 1, sorted(existing) def main() -> int: args = parse_args() logging.basicConfig( level=logging.DEBUG if args.verbose else logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s", ) # Load support data + template + handcrafted corpus. support = _load_json(SUPPORT_PATH) handcrafted = _load_handcrafted() valid_asset_ids = _validator.load_valid_asset_ids(ASSET_CSV) family_matrix = support["scenario_family_matrix"]["families"] op_contexts = support["operational_context_profiles"]["profiles"] families = args.family or list(family_matrix.keys()) rng = random.Random(args.seed) if args.seed is not None else random.Random() knowledge_plugin_hash = _stable_hash(SUPPORT_PATH) batch_id = args.batch_id or ( f"{dt.date.today().isoformat()}_{rng.randint(1000, 9999)}" ) out_dir = args.out_dir or (GENERATED_ROOT / batch_id) out_dir.mkdir(parents=True, exist_ok=True) (out_dir / "prompts").mkdir(exist_ok=True) (out_dir / "raw_responses").mkdir(exist_ok=True) # Refuse to silently overwrite an existing batch. Without this guard, the # documented "loop one --batch-id across families" pattern would reset # next_id=1 every iteration and rewrite SGT-GEN-001.json once per family. next_id, existing_ids = _scan_existing_batch(out_dir) if existing_ids and not args.append: log.error( "batch dir %s already contains %d scenario file(s) (%s..%s). " "Pass --append to continue numbering from SGT-GEN-%03d, or pick a " "different --batch-id.", _display_path(out_dir), len(existing_ids), existing_ids[0], existing_ids[-1], next_id, ) return 1 log.info("batch_id=%s out_dir=%s dry_run=%s", batch_id, out_dir, args.dry_run) log.info("families=%s n=%d model=%s", families, args.n, args.model) log.info("knowledge_plugin_version=%s", knowledge_plugin_hash) if args.append and existing_ids: log.info( "append mode: continuing from SGT-GEN-%03d (existing: %d scenario(s))", next_id, len(existing_ids), ) scenarios_emitted: list[dict[str, Any]] = [] invocation_starting_id = next_id # Asset rotation: deterministically walk through T-001..T-020 across the # batch (ordered by next_id) so a single seed doesn't collapse every # scenario onto the same transformer. The v0.1 first batch landed all 5 # scenarios on T-005 because the model has a strong asset bias at # temperature=0.7. PROMPT_VERSION v0.2 fix. asset_pool: list[str] = sorted(valid_asset_ids) if not asset_pool: log.error("no valid asset IDs available; cannot pin asset_id in prompts") return 1 for family in families: family_spec = family_matrix[family] for i in range(args.n): scenario_id = f"SGT-GEN-{next_id:03d}" prompt_label = f"{family}_{scenario_id}" # Walk asset_pool by scenario index (next_id-1) modulo pool size. # Across an N-scenario batch this gives N different assets when # N <= 20; wraps cleanly for larger batches. assigned_asset = asset_pool[(next_id - 1) % len(asset_pool)] prompt = build_prompt( family, family_spec, op_contexts, support, rng, asset_id=assigned_asset, ) (out_dir / "prompts" / f"{prompt_label}.txt").write_text( prompt, encoding="utf-8" ) log.info( "[%s] built prompt (chars=%d) -> %s", scenario_id, len(prompt), prompt_label, ) if args.dry_run: log.info("[%s] dry-run: skipping LLM call", scenario_id) next_id += 1 continue try: raw = call_llm(prompt, model=args.model, temperature=args.temperature) except Exception as exc: log.error("[%s] LLM call failed: %s", scenario_id, exc) next_id += 1 continue (out_dir / "raw_responses" / f"{prompt_label}.json").write_text( raw, encoding="utf-8" ) try: scenario = parse_response(raw) except json.JSONDecodeError as exc: log.error("[%s] response was not valid JSON: %s", scenario_id, exc) next_id += 1 continue scenario = attach_provenance( scenario, scenario_id=scenario_id, family=family, model=args.model, batch_id=batch_id, knowledge_plugin_hash=knowledge_plugin_hash, ) scenario["nearest_handcrafted_comparator"] = ( _nearest_handcrafted_comparator(scenario, handcrafted) ) errors = validate_scenario(scenario, valid_asset_ids) if errors: log.warning( "[%s] validation failed (%d errors); writing to invalid/ for inspection", scenario_id, len(errors), ) for err in errors: log.warning("[%s] %s", scenario_id, err) invalid_dir = out_dir / "invalid" invalid_dir.mkdir(exist_ok=True) (invalid_dir / f"{scenario_id}.json").write_text( json.dumps({"scenario": scenario, "errors": errors}, indent=2), encoding="utf-8", ) else: target = out_dir / f"{scenario_id}.json" target.write_text( json.dumps(scenario, indent=2) + "\n", encoding="utf-8" ) scenarios_emitted.append(scenario) log.info("[%s] OK -> %s", scenario_id, _display_path(target)) next_id += 1 # Batch manifest summarises the run for reviewer + reproducibility. # On --append, we LOAD any existing manifest and append a new # `invocations` entry rather than rewriting top-level fields, so the # batch keeps a faithful record of every generator pass that contributed # to it (model / seed / families / count for each invocation). manifest_path = out_dir / "batch_manifest.json" invocation_record = { "started_at": dt.datetime.now(dt.timezone.utc).isoformat(), "model": args.model, "temperature": args.temperature, "seed": args.seed, "families_requested": families, "n_per_family": args.n, "scenarios_emitted": [s["id"] for s in scenarios_emitted], "starting_scenario_id": f"SGT-GEN-{invocation_starting_id:03d}", "dry_run": args.dry_run, "append": args.append, } if args.append and manifest_path.exists(): manifest = json.loads(manifest_path.read_text(encoding="utf-8")) manifest.setdefault("invocations", []).append(invocation_record) # Keep the cumulative scenarios_emitted list in sync so consumers # don't have to walk every invocation block. cumulative = list(manifest.get("scenarios_emitted", [])) cumulative.extend(invocation_record["scenarios_emitted"]) # Deduplicate while preserving order in case an earlier append # rewrote a scenario id (it shouldn't, but defensive). seen: set[str] = set() manifest["scenarios_emitted"] = [ i for i in cumulative if not (i in seen or seen.add(i)) ] manifest["last_updated_at"] = invocation_record["started_at"] else: manifest = { "batch_id": batch_id, "created_at": invocation_record["started_at"], "last_updated_at": invocation_record["started_at"], "prompt_version": PROMPT_VERSION, "knowledge_plugin_version": knowledge_plugin_hash, "generator_script": "scripts/generate_scenarios.py", "support_data": SUPPORT_PATH.relative_to(_REPO_ROOT).as_posix(), "handcrafted_corpus_size": len(handcrafted), "scenarios_emitted": list(invocation_record["scenarios_emitted"]), "invocations": [invocation_record], } manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8") log.info("batch manifest written to %s", _display_path(manifest_path)) log.info( "emitted %d scenario(s) this invocation; batch total: %d", len(scenarios_emitted), len(manifest["scenarios_emitted"]), ) return 0 if __name__ == "__main__": raise SystemExit(main())