Upload folder using huggingface_hub

scripts/augment_ops_coverage.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""
+augment_ops_coverage.py
+Create op-augmented plans from a cleaned AttackPlan JSONL.
+
+Usage:
+  %run scripts/augment_ops_coverage.py --src scripts/train_attackplan.filtered.jsonl --sem kb/specs/point_semantics.json --out scripts/train_attackplan.aug.jsonl
+"""
+from __future__ import annotations
+import argparse, json, random
+from pathlib import Path
+
+def load_sem(p): return json.loads(Path(p).read_text(encoding="utf-8"))
+
+def coerce_num(x):
+    if isinstance(x, (int, float)): return float(x)
+    try: return float(str(x))
+    except Exception: return None
+
+def make_numeric_variants(it, spec, rng):
+    base = []
+    v = it.get("attack_value")
+    num = coerce_num(v)
+    if num is None: return base
+    ops = spec.get("ops", [])
+    inc = spec.get("numeric_increase_pct", 0.10)
+    dec = spec.get("numeric_decrease_pct", 0.10)
+    scales = spec.get("numeric_scale_factors", [0.5, 1.5])
+
+    if "increase" in ops: 
+        j = dict(it); j["op"] = "increase"; j["attack_value"] = round(num * (1 + inc), 3); base.append(j)
+    if "decrease" in ops: 
+        j = dict(it); j["op"] = "decrease"; j["attack_value"] = round(num * (1 - dec), 3); base.append(j)
+    if "scale" in ops:
+        for s in scales:
+            j = dict(it); j["op"] = "scale"; j["attack_value"] = round(num * s, 3); base.append(j)
+    return base
+
+def make_enum_variants(it, spec):
+    base = []
+    vals = [str(v).upper() for v in spec.get("values", [])]
+    if not vals: return base
+    cur = str(it.get("attack_value", "")).upper()
+    if "open" in spec.get("ops", []):
+        j = dict(it); j["op"] = "open";  j["attack_value"] = "OPEN";  base.append(j)
+    if "close" in spec.get("ops", []):
+        j = dict(it); j["op"] = "close"; j["attack_value"] = "CLOSED"; base.append(j)
+    if "trip" in spec.get("ops", []) and "OPEN" in vals:
+        j = dict(it); j["op"] = "trip";  j["attack_value"] = "OPEN";  base.append(j)
+    return base
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--src", required=True)
+    ap.add_argument("--sem", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--seed", type=int, default=7)
+    ap.add_argument("--max_aug_per_item", type=int, default=2, help="cap how many variants per original item")
+    args = ap.parse_args()
+
+    rng = random.Random(args.seed)
+    sem = load_sem(args.sem)
+    props = sem.get("properties", {})
+    defaults = sem.get("defaults", {})
+
+    src_lines = Path(args.src).read_text(encoding="utf-8-sig").splitlines()
+    out = []
+    n_src = 0; n_aug_plans = 0
+
+    for ln in src_lines:
+        if not ln.strip(): continue
+        plan = json.loads(ln)
+        n_src += 1
+        out.append(ln)  # keep original
+
+        # Make a simple one-item plan per augmented variant for clarity
+        for it in plan.get("plan", []):
+            point = it.get("point","")
+            spec = dict(defaults); spec.update(props.get(point, {}))
+            t = spec.get("type")
+            variants = []
+            if t in {"number","number_or_complex"}:
+                variants = make_numeric_variants(it, spec, rng)
+            elif t == "enum":
+                variants = make_enum_variants(it, spec)
+
+            rng.shuffle(variants)
+            for v in variants[:args.max_aug_per_item]:
+                out.append(json.dumps({
+                    "version": plan.get("version","1.1"),
+                    "time": plan.get("time", {"start_s":0,"end_s":60}),
+                    "mim": plan.get("mim", {"active":True,"selected":["MIM1","MIM2","MIM3","MIM4"]}),
+                    "plan": [v],
+                    "compile_hints": plan.get("compile_hints", {"scenario_id":"a"})
+                }, ensure_ascii=False))
+                n_aug_plans += 1
+
+    Path(args.out).write_text("\n".join(out) + "\n", encoding="utf-8")
+    print(f"[done] plans_in={n_src}, aug_plans_added={n_aug_plans}, total_out={len(out)}")
+    print(f"[wrote] {Path(args.out).resolve()}")
+
+if __name__ == "__main__":
+    main()

scripts/build_rag_index.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+import argparse, json, os, glob
+from pathlib import Path
+import faiss
+from sentence_transformers import SentenceTransformer
+import numpy as np
+
+def gather_docs():
+    items=[]
+    # JSON examples/snippets
+    for fp in glob.glob("kb/examples/*.json")+glob.glob("kb/snippets/json/*.json"):
+        try:
+            txt = Path(fp).read_text(encoding="utf-8")
+            items.append(("json", fp, txt))
+        except: pass
+    # GLM snippets as text
+    for fp in glob.glob("kb/snippets/glm/*"):
+        try:
+            if Path(fp).suffix.lower() in {".glm",".md",""}:
+                txt = Path(fp).read_text(encoding="utf-8")
+                items.append(("glm", fp, txt))
+        except: pass
+    # cheatsheet + semantics
+    for fp in ["kb/cheatsheets/property_glossary.md","kb/specs/point_semantics.json"]:
+        if Path(fp).exists():
+            items.append(("text", fp, Path(fp).read_text(encoding="utf-8")))
+    return items
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", default="sentence-transformers/all-MiniLM-L6-v2")  # small + fast
+    ap.add_argument("--outdir", default="rag_index")
+    args = ap.parse_args()
+
+    os.makedirs(args.outdir, exist_ok=True)
+    docs = gather_docs()
+    if not docs: raise SystemExit("No docs to index.")
+    model = SentenceTransformer(args.model)
+    corpus = [f"[{k}] {p}\n{t}" for (k,p,t) in docs]
+    emb = model.encode(corpus, normalize_embeddings=True, convert_to_numpy=True, show_progress_bar=True)
+    dim = emb.shape[1]
+    index = faiss.IndexFlatIP(dim)
+    index.add(emb)
+    faiss.write_index(index, str(Path(args.outdir, "kb.faiss")))
+    Path(args.outdir, "kb_meta.json").write_text(json.dumps(
+        {"paths":[p for (_,p,_) in docs], "model": args.model}, indent=2), encoding="utf-8")
+    print("[ok] indexed", len(docs), "docs to", Path(args.outdir,"kb.faiss").resolve())
+
+if __name__ == "__main__":
+    main()

scripts/filter_attackplan_jsonl.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+"""
+filter_attackplan_jsonl.py
+Align AttackPlan JSONL to kb/specs/point_semantics.json and GLM-backed encodings.
+
+- Keeps capacitor phase switches (switchA/B/C) as enums.
+- Normalizes real switch objects: switch.* {switchA|switchB|switchC} -> status (only for switches).
+- Drops unknown/low-confidence points per semantics.
+- Coerces numeric/complex vs enum values.
+- Optionally rewrites regulator_X.tap_pos_* -> regulator_configuration_X.tap_pos_*
+
+Usage:
+  python3 scripts/filter_attackplan_jsonl.py \
+    --src "C:/.../train_attackplan.jsonl" \
+    --sem "kb/specs/point_semantics.json" \
+    --out "scripts/train_attackplan.filtered.jsonl" \
+    --fix-switch --map-regcfg --debug
+"""
+from __future__ import annotations
+import argparse, json, re
+from pathlib import Path
+
+CAP_REGEX = re.compile(r'(^|[_.])cap_', re.I)
+SW_REGEX  = re.compile(r'(switch|microgrid_switch)', re.I)
+REG_REGEX = re.compile(r'(^|[_.])regulator_(\d+)$', re.I)
+RCF_REGEX = re.compile(r'(^|[_.])regulator_configuration_(\d+)$', re.I)
+
+def load_semantics(p: Path) -> dict:
+    j = json.loads(p.read_text(encoding="utf-8"))
+    props = j.get("properties", {})
+    # resolve "like" references
+    for k, v in list(props.items()):
+        if "like" in v:
+            ref = props.get(v["like"], {})
+            merged = dict(ref); merged.update({kk: vv for kk, vv in v.items() if kk != "like"})
+            props[k] = merged
+    j["properties"] = props
+    return j
+
+def is_complex_str(s: str) -> bool:
+    return bool(re.fullmatch(r"\s*-?\d+(\.\d+)?\s*\+\s*-?\d+(\.\d+)?j\s*", s))
+
+def coerce_numeric(x):
+    if isinstance(x, (int, float)): return float(x)
+    try: return float(str(x))
+    except Exception: return None
+
+def parse_name(item_name: str) -> tuple[str,str]:
+    """Return (device, point) from 'MIM2.device.point' or 'device.point'."""
+    parts = item_name.split(".")
+    if len(parts) >= 3 and parts[0].upper().startswith("MIM"):
+        return parts[1], parts[-1]
+    if len(parts) >= 2:
+        return parts[0], parts[-1]
+    return item_name, ""
+
+def maybe_fix_switch_point(device: str, point: str) -> str:
+    """
+    - For capacitor objects (cap_*), KEEP switchA/B/C.
+    - For real switch objects, normalize switchA/B/C -> status.
+    """
+    if CAP_REGEX.search(device):
+        return point
+    if SW_REGEX.search(device) and point.lower() in {"switcha","switchb","switchc"}:
+        return "status"
+    return point
+
+def maybe_map_reg_config(item_name: str) -> str:
+    """regulator_n.* -> regulator_configuration_n.* if not already mapped."""
+    if RCF_REGEX.search(item_name):
+        return item_name
+    m = REG_REGEX.search(item_name)
+    if not m: 
+        return item_name
+    idx = m.group(2)
+    return REG_REGEX.sub(lambda _: f"regulator_configuration_{idx}", item_name)
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--src", required=True)
+    ap.add_argument("--sem", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--allow-low", nargs="*", default=[], help="Points to allow even if confidence=low.")
+    ap.add_argument("--fix-switch", dest="fix_switch", action="store_true",
+                    help="Normalize switch.* switchA/B/C -> status for real switches")
+    ap.add_argument("--map-regcfg", dest="map_regcfg", action="store_true",
+                    help="Route regulator_X.* -> regulator_configuration_X.*")
+    ap.add_argument("--debug", action="store_true")
+    args = ap.parse_args()
+
+    src_path = Path(args.src)
+    sem_path = Path(args.sem)
+    if args.debug:
+        print("[debug] src:", src_path.resolve(), "exists:", src_path.exists())
+        print("[debug] sem:", sem_path.resolve(), "exists:", sem_path.exists())
+        print("[debug] out:", Path(args.out).resolve())
+
+    if not src_path.exists():
+        raise SystemExit(f"[error] src not found: {src_path}")
+    if not sem_path.exists():
+        raise SystemExit(f"[error] sem not found: {sem_path}")
+
+    sem = load_semantics(sem_path)
+    props = sem["properties"]
+    default_drop_low = sem.get("exclusions", {}).get("default_drop_if_confidence_low", True)
+    allow_low = set(sem.get("exclusions", {}).get("allow_low_confidence", []) + args.allow_low)
+
+    src_lines = src_path.read_text(encoding="utf-8-sig").splitlines()
+    out_lines = []
+    n_dropped_items = n_sw_fixed = n_reg_map = 0
+
+    for ln in src_lines:
+        if not ln.strip(): continue
+        try:
+            plan = json.loads(ln)
+        except Exception:
+            continue
+
+        new_items = []
+        for it in plan.get("plan", []):
+            name = it.get("name", "")
+            device, _ = parse_name(name)
+
+            # switch normalization
+            if args.fix_switch:
+                new_point = maybe_fix_switch_point(device, it.get("point",""))
+                if new_point != it.get("point"):
+                    it["point"] = new_point
+                    if "." in name:
+                        parts = name.split(".")
+                        parts[-1] = new_point
+                        it["name"] = ".".join(parts)
+                    n_sw_fixed += 1
+
+            # regulator mapping
+            if args.map_regcfg and it.get("point","").startswith("tap_pos_") and REG_REGEX.search(device):
+                old = it["name"]
+                it["name"] = maybe_map_reg_config(it["name"])
+                if it["name"] != old:
+                    n_reg_map += 1
+
+            spec = props.get(it.get("point",""), {})
+            # policy: drop if unknown or low-confidence (unless allowed)
+            if not spec or spec.get("drop"):
+                n_dropped_items += 1; continue
+            if default_drop_low and spec.get("confidence") == "low" and it.get("point") not in allow_low:
+                n_dropped_items += 1; continue
+
+            typ = spec.get("type")
+            val = it.get("attack_value")
+
+            if typ == "enum":
+                sval = str(val).upper() if val is not None else ""
+                vals = [str(v).upper() for v in spec.get("values",[])]
+                if sval not in vals:
+                    if sval in {"1","TRUE"} and "CLOSED" in vals:
+                        it["attack_value"] = "CLOSED"
+                    elif sval in {"0","FALSE"} and "OPEN" in vals:
+                        it["attack_value"] = "OPEN"
+                    else:
+                        n_dropped_items += 1; continue
+
+            elif typ in {"number","integer"}:
+                num = coerce_numeric(val)
+                if num is None:
+                    n_dropped_items += 1; continue
+                if typ == "integer":
+                    num = int(round(num))
+                it["attack_value"] = num
+
+            elif typ == "number_or_complex":
+                if isinstance(val, str) and is_complex_str(val):
+                    pass
+                else:
+                    num = coerce_numeric(val)
+                    if num is None:
+                        n_dropped_items += 1; continue
+                    it["attack_value"] = num
+
+            new_items.append(it)
+
+        if new_items:
+            plan["plan"] = new_items
+            out_lines.append(json.dumps(plan, ensure_ascii=False))
+
+    Path(args.out).write_text("\n".join(out_lines) + "\n", encoding="utf-8")
+    print(f"[done] plans_in={len(src_lines)}, plans_out={len(out_lines)}, "
+          f"items_dropped={n_dropped_items}, switches_normalized={n_sw_fixed}, regulators_mapped={n_reg_map}")
+    print(f"[wrote] {Path(args.out).resolve()}")
+
+if __name__ == "__main__":
+    main()

scripts/guardrails.py

@@ -0,0 +1,224 @@
+# scripts/guardrails.py
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Set
+
+
+def _read_json(path: str) -> Dict[str, Any]:
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+class TargetRegistry:
+    def __init__(self, data: Dict[str, Any]):
+        self.data = data or {}
+        self.canonical = self.data.get("canonical", {})
+        self.points = self.data.get("points", {})
+        self.synonyms = self.data.get("synonyms", {})
+        self.mim_default_by_mg = self.data.get("mim_default_by_mg", {})
+
+        # Build quick lookup of allowed devices per mg (union of all groups)
+        self.allowed_by_mg: Dict[str, Set[str]] = {}
+        for group, mg_map in self.canonical.items():
+            for mg, devices in mg_map.items():
+                self.allowed_by_mg.setdefault(mg, set()).update(devices)
+
+        # Flatten device synonyms
+        self.dev_syn = self.synonyms.get("device", {})
+        self.point_syn = self.synonyms.get("point", {})
+        self.mim_syn = self.synonyms.get("mim", {})
+
+    @classmethod
+    def from_json(cls, path: str) -> "TargetRegistry":
+        return cls(_read_json(path))
+
+    def allowed_devices(self, mg: Optional[str]) -> Set[str]:
+        if not mg:
+            return set()
+        return self.allowed_by_mg.get(mg, set())
+
+    def canonicalize_mim(self, mim: Optional[str]) -> Optional[str]:
+        if mim is None:
+            return None
+        m = self.mim_syn.get(mim, mim)
+        m = m.upper()
+        if re.fullmatch(r"MIM[1-4]", m):
+            return m
+        return None  # unknown MIM label
+
+    def canonicalize_point(self, point: str) -> str:
+        return self.point_syn.get(point, point)
+
+    def canonicalize_device(self, dev: str, mg: Optional[str]) -> str:
+        # direct synonym
+        dev2 = self.dev_syn.get(dev, dev)
+
+        # If device has a dot (like mg1.cap_01), squash using mg+core
+        if "." in dev2 and mg:
+            core = dev2.split(".")[-1]
+            candidate = f"{mg}{core}"
+            # Try mg-prefixed candidate first
+            if candidate in self.allowed_devices(mg):
+                return candidate
+            # Try synonym mapping of the core
+            dev3 = self.dev_syn.get(core, core)
+            candidate2 = f"{mg}{dev3}"
+            if candidate2 in self.allowed_devices(mg):
+                return candidate2
+
+        # If device lacks mg prefix but mg is present, and mg+dev is allowed, use it
+        if mg and not dev2.startswith(mg):
+            cand = f"{mg}{dev2}"
+            if cand in self.allowed_devices(mg):
+                return cand
+
+        # If already allowed, keep it
+        if mg and dev2 in self.allowed_devices(mg):
+            return dev2
+
+        # Fall back to synonym again (idempotent) or original
+        return dev2
+
+    def pick_default_mim(self, mg: Optional[str]) -> Optional[str]:
+        if mg is None:
+            return None
+        return self.mim_default_by_mg.get(mg)
+
+
+def augment_prompt_with_allowlist(instruction: str, reg: TargetRegistry) -> str:
+    # Append a short allow-list hint (kept compact)
+    def bucket_preview(mg: str) -> str:
+        items = sorted(list(reg.allowed_devices(mg)))[:8]
+        return f"{mg}: {', '.join(items)}" if items else ""
+
+    hints = []
+    for mg in ("mg1", "mg2", "mg3", "substation", "unmapped"):
+        s = bucket_preview(mg)
+        if s:
+            hints.append(s)
+
+    if hints:
+        instruction += (
+            "\nAllowed device names (examples):\n"
+            + "\n".join(hints)
+            + "\nUse exactly one dot in `name`: [optional MIM].<device>.<point>\n"
+        )
+    return instruction
+
+
+def _parse_name(name: str) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    # Accepts:
+    #  MIM1.device.point
+    #  device.point
+    # If multiple dots exist (bad), we capture best-effort pieces.
+    parts = name.split(".")
+    if len(parts) >= 3 and re.fullmatch(r"MIM[1-4]", parts[0]):
+        mim = parts[0]
+        point = parts[-1]
+        device = ".".join(parts[1:-1])  # may contain dots → caller will clean
+        return mim, device, point
+    elif len(parts) >= 2:
+        point = parts[-1]
+        device = ".".join(parts[:-1])   # may contain dots → caller will clean
+        return None, device, point
+    return None, None, None
+
+
+def _build_name(mim: Optional[str], device: str, point: str) -> str:
+    if mim:
+        return f"{mim}.{device}.{point}"
+    return f"{device}.{point}"
+
+
+def _is_switch_point(point: str) -> bool:
+    return point in {"status", "switchA", "switchB", "switchC"}
+
+
+def _normalize_openclose(item: Dict[str, Any]) -> None:
+    op = item.get("op")
+    point = item.get("point")
+    if op in {"open", "close"} or _is_switch_point(point):
+        # Normalize values to uppercase OPEN/CLOSED
+        av = item.get("attack_value")
+        rv = item.get("real_value")
+        if isinstance(av, str):
+            item["attack_value"] = av.upper()
+        if isinstance(rv, str):
+            item["real_value"] = rv.upper()
+        # If op=open and attack_value missing → OPEN
+        if op == "open" and not item.get("attack_value"):
+            item["attack_value"] = "OPEN"
+        if op == "close" and not item.get("attack_value"):
+            item["attack_value"] = "CLOSED"
+        # Default real_value if absent (reasonable default)
+        if not item.get("real_value"):
+            item["real_value"] = "CLOSED" if item["attack_value"] == "OPEN" else "OPEN"
+
+
+def validate_and_fix_attackplan(
+    ap: Dict[str, Any],
+    reg: TargetRegistry,
+    strict: bool = False,
+    autofix: bool = True,
+    cutoff: float = 0.92,  # unused, kept for interface stability
+) -> Tuple[Dict[str, Any], List[str]]:
+    notes: List[str] = []
+
+    if not isinstance(ap, dict):
+        notes.append("attack plan is not a dict")
+        return ap, notes
+
+    # Fix top-level mim.selected using first item's scope if needed
+    plan: List[Dict[str, Any]] = ap.get("plan") or []
+    if plan:
+        scope0 = plan[0].get("scope", {})
+        mg0 = scope0.get("mg")
+        mim0 = scope0.get("mim")
+        mim0 = reg.canonicalize_mim(mim0) or reg.pick_default_mim(mg0)
+        # Constrain selected to a single MIM when we have one
+        if mim0:
+            ap.setdefault("mim", {})
+            ap["mim"]["active"] = True
+            ap["mim"]["selected"] = [mim0]
+
+    new_plan: List[Dict[str, Any]] = []
+
+    for it in plan:
+        scope = it.get("scope", {}) or {}
+        mg = scope.get("mg")
+        mim = reg.canonicalize_mim(scope.get("mim")) or reg.pick_default_mim(mg)
+
+        # Parse and canonicalize name parts
+        name = it.get("name", "")
+        mim_in, dev_raw, point_raw = _parse_name(name)
+        point = reg.canonicalize_point(point_raw) if point_raw else point_raw
+
+        # Choose mim priority: explicit in scope, else in name
+        mim_final = mim or reg.canonicalize_mim(mim_in)
+
+        # Canonicalize device using mg + synonyms
+        dev_final = reg.canonicalize_device(dev_raw or "", mg)
+
+        # If still unknown and strict, drop
+        if strict and mg and dev_final not in reg.allowed_devices(mg):
+            notes.append(f"dropped unknown device for mg={mg}: {dev_raw}")
+            continue
+
+        # Rebuild name with exactly one dot in device segment
+        if dev_final and point:
+            it["name"] = _build_name(mim_final, dev_final, point)
+
+        # Update scope.mim to the resolved one
+        if mim_final:
+            it.setdefault("scope", {})
+            it["scope"]["mim"] = mim_final
+
+        # Normalize switch/OPEN-CLOSED values
+        _normalize_openclose(it)
+
+        new_plan.append(it)
+
+    ap["plan"] = new_plan
+    return ap, notes

scripts/make_chat_from_plans.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+import json, argparse, uuid
+from pathlib import Path
+
+SYS = "You output ONLY JSON, no explanation. Validate against AttackPlan v1.1 semantics."
+
+def plan_to_prompt(p):
+    # small, human prompt summarizing the requested edits
+    bits=[]
+    for it in p.get("plan", [])[:6]:
+        op = it.get("op","set"); pt = it.get("point",""); val = it.get("attack_value")
+        nm = it.get("name","")
+        scope = (it.get("scope") or {})
+        area = scope.get("mg"); mim = scope.get("mim")
+        s = f"{op} {pt} on {nm} to {val}"
+        if mim: s += f" in {mim}"
+        if area: s += f" ({area})"
+        bits.append(s)
+    return "; ".join(bits) if bits else "Generate an AttackPlan JSON v1.1 for no-op."
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--src", required=True, help="scripts/train_attackplan.aug.jsonl (or filtered)")
+    ap.add_argument("--out", default="datasets/chat_attackplan.jsonl")
+    args = ap.parse_args()
+
+    src = Path(args.src).read_text(encoding="utf-8-sig").splitlines()
+    out = []
+    for ln in src:
+        if not ln.strip(): continue
+        obj = json.loads(ln)
+        prompt = plan_to_prompt(obj)
+        out.append({
+          "id": str(uuid.uuid4()),
+          "messages": [
+            {"role":"system","content":SYS},
+            {"role":"user","content":f"Task: {prompt}\nReturn ONLY the JSON."},
+            {"role":"assistant","content": json.dumps(obj, ensure_ascii=False)}
+          ]
+        })
+    Path(args.out).parent.mkdir(parents=True, exist_ok=True)
+    Path(args.out).write_text("\n".join(json.dumps(x, ensure_ascii=False) for x in out)+"\n", encoding="utf-8")
+    print("[ok] wrote", Path(args.out).resolve(), "rows:", len(out))
+
+if __name__ == "__main__":
+    main()

scripts/make_property_glossary.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+"""
+make_property_glossary.py
+Summarize properties from AttackPlan JSONL and merge semantics from kb/specs/point_semantics.json.
+
+Usage:
+  python scripts/make_property_glossary.py \
+    --src scripts/train_attackplan.filtered.jsonl \
+    --sem kb/specs/point_semantics.json
+"""
+from __future__ import annotations
+import argparse, json, statistics
+from pathlib import Path
+from collections import Counter, defaultdict
+
+def load_plans(src: Path):
+  raw = src.read_text(encoding="utf-8-sig").splitlines()
+  plans = []
+  for ln in raw:
+    s = ln.strip()
+    if not s: continue
+    try:
+      obj = json.loads(s)
+    except Exception:
+      continue
+    if isinstance(obj, dict) and isinstance(obj.get("plan"), list):
+      plans.append(obj)
+  return plans
+
+def coerce_num(x):
+  try: return float(str(x))
+  except Exception: return None
+
+def main():
+  ap = argparse.ArgumentParser()
+  ap.add_argument("--src", required=True, help="AttackPlan JSONL (filtered)")
+  ap.add_argument("--sem", required=True, help="Semantics JSON (kb/specs/point_semantics.json)")
+  args = ap.parse_args()
+
+  src = Path(args.src)
+  sem = json.loads(Path(args.sem).read_text(encoding="utf-8"))
+  props_sem = sem.get("properties", {})
+
+  plans = load_plans(src)
+  if not plans:
+    raise SystemExit(f"No AttackPlan rows in {src}")
+
+  freq = Counter()
+  vals = defaultdict(list)
+  ops  = Counter()
+  applys = Counter()
+
+  for plan in plans:
+    for it in plan.get("plan", []):
+      p = it.get("point","")
+      freq[p]+=1
+      ops[it.get("op","set")] += 1
+      applys[(it.get("scope") or {}).get("apply","both")] += 1
+      v = it.get("attack_value", None)
+      if v is not None: vals[p].append(v)
+
+  lines = []
+  lines.append("# Property Glossary (auto-generated)\n")
+  lines.append("**REALITY FILTER:** Items reflect your filtered dataset and semantics. If a property has low confidence in the semantics file, verify before relying on it.\n")
+  lines.append(f"- Source file: `{src}`\n")
+  lines.append(f"- Total plans: {len(plans)}\n")
+  lines.append(f"- Operation distribution: {dict(ops)}\n")
+  lines.append(f"- Scope.apply distribution: {dict(applys)}\n")
+  lines.append("\n---\n## Properties\n")
+
+  for prop, count in freq.most_common():
+    semp = props_sem.get(prop, {})
+    unit = semp.get("unit", "[n/a]")
+    conf = semp.get("confidence", "unknown")
+    notes = semp.get("notes", "")
+    # example values
+    ex_vals = vals[prop][:6]
+    nums = [coerce_num(v) for v in vals[prop]]
+    nums = [n for n in nums if n is not None]
+    if nums:
+      stats = f"min={min(nums):.3f}, p50={statistics.median(nums):.3f}, max={max(nums):.3f}"
+    else:
+      stats = "[n/a]"
+    # confidence label
+    conf_lbl = {"high":"[Verified]","medium":"[Inference]","low":"[Unverified]"}.get(conf, "[Unverified]")
+    # write section
+    lines.append(f"### `{prop}`  \n- **count:** {count}  \n- **unit:** {unit}  \n- **confidence:** {conf_lbl}  \n- **notes:** {notes or '[n/a]'}  \n- **examples:** {ex_vals}  \n- **numeric stats:** {stats}\n")
+
+  out = Path("kb/cheatsheets/property_glossary.md")
+  out.parent.mkdir(parents=True, exist_ok=True)
+  out.write_text("\n".join(lines), encoding="utf-8")
+  print("[ok] wrote", out.resolve())
+
+if __name__ == "__main__":
+  main()

scripts/run_hybrid_infer.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+import argparse, json, os, re, sys, time, random
+from pathlib import Path
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+from jsonschema import Draft7Validator
+
+# ---------------------------
+# RAG (optional)
+# ---------------------------
+def try_load_rag(index_path: str, kb_root: str):
+    if not index_path:
+        return None
+    try:
+        import faiss
+        from sentence_transformers import SentenceTransformer
+    except Exception:
+        print("[rag] sentence-transformers / faiss not available, skipping RAG.")
+        return None
+    if not os.path.exists(index_path):
+        print(f"[rag] index not found at {index_path}, skipping.")
+        return None
+    model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+    index = faiss.read_index(index_path)
+    return {"enc": model, "index": index, "kb_root": kb_root or ""}
+
+def rag_retrieve(rag, query: str, k: int):
+    if not rag:
+        return []
+    import numpy as np
+    vec = rag["enc"].encode([query])
+    D, I = rag["index"].search(vec, k)
+    I = I[0].tolist()
+    # If you have a mapping file alongside the index, use it; else emit stubs.
+    mapping_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "rag_index", "kb.mapping.json")
+    out = []
+    if os.path.exists(mapping_path):
+        try:
+            with open(mapping_path, "r", encoding="utf-8") as f:
+                mapping = json.load(f)
+            for i in I:
+                s = mapping.get(str(i))
+                out.append(s if s else f"[KB#{i}]")
+        except Exception:
+            out = [f"[KB#{i}]" for i in I]
+    else:
+        out = [f"[KB#{i}]" for i in I]
+    return out
+
+# ---------------------------
+# Schema helpers
+# ---------------------------
+def load_schema(path: str):
+    if not path:
+        return None
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def validate_schema(obj, schema):
+    if not schema:
+        return True, []
+    v = Draft7Validator(schema)
+    errs = sorted(v.iter_errors(obj), key=lambda e: e.path)
+    if errs:
+        msgs = []
+        for e in errs:
+            loc = ".".join([str(p) for p in e.path])
+            msgs.append(f"{loc or '<root>'}: {e.message}")
+        return False, msgs
+    return True, []
+
+# ---------------------------
+# Guard (allow list + coerce)
+# ---------------------------
+def _load_targets(path: str):
+    if not path:
+        return {"allow": [], "allow_prefix": [], "coerce": {}}
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    allow = list(dict.fromkeys(data.get("allow", [])))
+    allow_prefix = list(dict.fromkeys(data.get("allow_prefix", [])))
+    coerce = {str(k).lower(): v for k, v in data.get("coerce", {}).items()}
+    print(f"[guard] strict target list loaded: {len(allow)} names, {len(allow_prefix)} prefixes")
+    return {"allow": allow, "allow_prefix": allow_prefix, "coerce": coerce}
+
+def _base_name(full: str) -> str:
+    parts = full.split(".", 1)
+    if len(parts) == 2 and parts[0].startswith("MIM") and parts[0][3:].isdigit():
+        return parts[1]
+    return full
+
+def _is_allowed(name: str, allow: list, allow_prefix: list) -> bool:
+    bn = _base_name(name)
+    if name in allow or bn in allow:
+        return True
+    for p in allow_prefix:
+        if name.startswith(p) or bn.startswith(p):
+            return True
+    return False
+
+def _coerce_value(val, coerce_map: dict):
+    if isinstance(val, str):
+        key = val.strip().lower()
+        if key in coerce_map:
+            return coerce_map[key]
+    if isinstance(val, bool):
+        return "OPEN" if val else "CLOSED"
+    return val
+
+def sanitize_step_scope(step: dict):
+    # Fix common schema issues for scope.mim
+    name = step.get("name", "")
+    sc = step.get("scope", {}) or {}
+    mim = sc.get("mim", None)
+    if isinstance(mim, bool):
+        mim = None
+    if mim is None and isinstance(name, str) and name.startswith("MIM"):
+        m = re.match(r"^(MIM[1-4])\.", name)
+        if m: mim = m.group(1)
+    sc["mim"] = mim
+    step["scope"] = sc
+    return step
+
+def guard_and_coerce(plan: list, targets: dict, strict: bool) -> list:
+    allow = targets.get("allow", [])
+    allow_prefix = targets.get("allow_prefix", [])
+    coerce_map = targets.get("coerce", {})
+    kept, rejects = [], []
+    for i, step in enumerate(plan or []):
+        name = step.get("name", "")
+        step = sanitize_step_scope(step)
+        ok = _is_allowed(name, allow, allow_prefix)
+        if not ok and strict:
+            rejects.append((i, name, "not_in_allowlist"))
+            continue
+        step["attack_value"] = _coerce_value(step.get("attack_value"), coerce_map)
+        kept.append(step)
+    if rejects:
+        for i, n, why in rejects:
+            print(f"[reject {i}] guard: {n} -> {why}")
+        if not kept:
+            raise ValueError("All steps rejected by guard.")
+    return kept
+
+# ---------------------------
+# Prompting & extraction
+# ---------------------------
+def build_prompt(task: str, user_prompt: str, rag_snippets=None, must_names=None):
+    assert task in {"attackplan", "chat"}
+    parts = []
+    if task == "attackplan":
+        parts.append("You output only AttackPlan v1.1 JSON. No other text.")
+        if rag_snippets:
+            parts.append("\nContext")
+            for snip in rag_snippets:
+                parts.append(snip)
+        if must_names:
+            parts.append("\nHard constraints:")
+            parts.append(" - Your plan MUST include the following names (exact match) at least once:")
+            for n in must_names:
+                parts.append(f"   * {n}")
+        parts.append("\nInstruction")
+        parts.append(user_prompt.strip())
+        parts.append("\nKeys: version, time, mim, plan\n### Response:")
+    else:
+        parts.append(user_prompt.strip())
+    return "\n".join(parts)
+
+def extract_first_json(text: str):
+    # Try code fences first
+    fence = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.S | re.I)
+    if fence:
+        try:
+            return json.loads(fence.group(1))
+        except Exception:
+            pass
+    # Brace scanner (no recursive regex)
+    stack = []
+    start = None
+    for i, ch in enumerate(text):
+        if ch == "{":
+            if not stack:
+                start = i
+            stack.append("{")
+        elif ch == "}":
+            if stack:
+                stack.pop()
+                if not stack and start is not None:
+                    candidate = text[start:i+1]
+                    try:
+                        return json.loads(candidate)
+                    except Exception:
+                        start = None  # keep scanning
+    raise ValueError("No JSON object found in model output.")
+
+def plan_contains_all_names(plan: list, must_names: list) -> bool:
+    names = {step.get("name", "") for step in (plan or [])}
+    return all(n in names for n in must_names)
+
+# ---------------------------
+# Model loading / generation
+# ---------------------------
+def load_model_and_tokenizer(base: str, adapter: str, local_files_only: bool):
+    tok = AutoTokenizer.from_pretrained(base, use_fast=True, local_files_only=local_files_only)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    model = AutoModelForCausalLM.from_pretrained(
+        base,
+        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+        device_map="auto",
+        local_files_only=local_files_only,
+    )
+    if adapter:
+        model = PeftModel.from_pretrained(model, adapter, local_files_only=local_files_only)
+        print(f"[model] Loaded PEFT adapter: {adapter}")
+    return model, tok
+
+def generate_json(model, tok, prompt, max_new_tokens=320, temp=0.2, top_p=0.9):
+    inputs = tok(prompt, return_tensors="pt", padding=True, truncation=True).to(model.device)
+    with torch.no_grad():
+        out = model.generate(
+            **inputs,
+            max_new_tokens=int(max_new_tokens),
+            do_sample=True,
+            temperature=float(temp),
+            top_p=float(top_p),
+            pad_token_id=tok.pad_token_id,
+            eos_token_id=tok.eos_token_id,
+        )
+    text = tok.decode(out[0], skip_special_tokens=True)
+    return text
+
+# ---------------------------
+# Main
+# ---------------------------
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--base", required=True, help="HF model id or path")
+    ap.add_argument("--adapter", default="", help="PEFT adapter path")
+    ap.add_argument("--task", choices=["attackplan", "chat"], default="attackplan")
+    ap.add_argument("--schema", default="", help="JSON schema for validation")
+    ap.add_argument("--prompt", required=True, help="User instruction")
+    ap.add_argument("--rag_index", default="", help="FAISS index path")
+    ap.add_argument("--kb_root", default="", help="KB root for RAG (optional)")
+    ap.add_argument("--idx", type=int, default=4, help="RAG top-k")
+    ap.add_argument("--targets", default="", help="allowed_targets.json")
+    ap.add_argument("--strict_targets", action="store_true")
+    ap.add_argument("--must_names", default="", help="Comma separated exact names that MUST appear")
+    ap.add_argument("--max_attempts", type=int, default=3)
+    ap.add_argument("--temp", type=float, default=0.2)
+    ap.add_argument("--top_p", type=float, default=0.9)
+    ap.add_argument("--max_new_tokens", type=int, default=320)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--save", default="", help="Optional path to save final JSON")
+    ap.add_argument("--offline", action="store_true", help="Force offline (no HF Hub network)")
+    args = ap.parse_args()
+
+    # Environment hardening: never push, optional offline
+    os.environ.setdefault("HF_HUB_DISABLE_TELEMETRY", "1")
+    os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
+    if args.offline:
+        os.environ["HF_HUB_OFFLINE"] = "1"
+
+    random.seed(args.seed)
+    torch.manual_seed(args.seed)
+
+    # Load components
+    schema = load_schema(args.schema)
+    targets = _load_targets(args.targets) if args.targets else {"allow": [], "allow_prefix": [], "coerce": {}}
+    rag = try_load_rag(args.rag_index, args.kb_root)
+    model, tok = load_model_and_tokenizer(args.base, args.adapter, local_files_only=args.offline)
+
+    must_names = [s.strip() for s in args.must_names.split(",") if s.strip()] if args.must_names else []
+
+    attempts = 0
+    last_errs = []
+    final = None
+
+    while attempts < max(1, args.max_attempts):
+        attempts += 1
+        snippets = rag_retrieve(rag, args.prompt, args.idx) if rag else None
+        prompt_text = build_prompt(args.task, args.prompt, snippets, must_names)
+
+        raw = generate_json(model, tok, prompt_text, args.max_new_tokens, args.temp, args.top_p)
+        try:
+            obj = extract_first_json(raw)
+        except Exception as e:
+            print(f"[attempt {attempts}] parse_error: {e}")
+            last_errs.append(f"parse_error: {e}")
+            continue
+
+        if args.task == "attackplan":
+            if "plan" not in obj or not isinstance(obj["plan"], list):
+                print(f"[attempt {attempts}] schema_error: plan missing or not a list")
+                last_errs.append("schema: plan missing")
+                continue
+
+            try:
+                obj["plan"] = guard_and_coerce(obj["plan"], targets, strict=args.strict_targets)
+            except Exception as e:
+                print(f"[attempt {attempts}] guard_reject: {e}")
+                last_errs.append(f"guard_reject: {e}")
+                continue
+
+            if must_names and not plan_contains_all_names(obj["plan"], must_names):
+                print(f"[attempt {attempts}] must_names not satisfied, retrying…")
+                last_errs.append("must_names")
+                continue
+
+        ok, errs = validate_schema(obj, schema)
+        if not ok:
+            for i, m in enumerate(errs[:5], 1):
+                print(f"[attempt {attempts}] schema_error {i}: {m}")
+            last_errs.extend(errs)
+            continue
+
+        final = obj
+        break
+
+    if final is None:
+        print("[error] failed to produce a valid plan.")
+        if last_errs:
+            print("Last errors:")
+            for m in last_errs[-10:]:
+                print(" -", m)
+        sys.exit(2)
+
+    out_text = json.dumps(final, ensure_ascii=False)
+    print(out_text)
+
+    if args.save:
+        Path(os.path.dirname(args.save) or ".").mkdir(parents=True, exist_ok=True)
+        with open(args.save, "w", encoding="utf-8") as f:
+            f.write(out_text)
+        print(f"[ok] saved to {args.save}")
+
+if __name__ == "__main__":
+    main()

scripts/seed_kb_examples.py

@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+"""
+seed_kb_examples.py
+Create prompt→AttackPlan examples for RAG from train_attackplan.jsonl
+
+Usage (from repo root):
+  %run scripts/seed_kb_examples.py
+  # or choose a different source / count
+  %run scripts/seed_kb_examples.py --src scripts/train_attackplan.jsonl --k 40
+"""
+
+from __future__ import annotations
+import argparse, json, re, random
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+
+# ----------------------
+# Helpers
+# ----------------------
+
+def load_plans(src: Path) -> List[Dict[str, Any]]:
+    lines = src.read_text(encoding="utf-8").splitlines()
+    out = []
+    for ln in lines:
+        ln = ln.strip()
+        if not ln:
+            continue
+        try:
+            obj = json.loads(ln)
+            # tolerate files that contain chat rows by accident
+            if isinstance(obj, dict) and "plan" in obj and isinstance(obj["plan"], list):
+                out.append(obj)
+        except Exception:
+            continue
+    return out
+
+def infer_device_name(item_name: str) -> str:
+    # item_name may be:
+    # "MIM2.mg1microgrid_switch2.status" or "mg1load_41.constant_power_A"
+    # Take the middle chunk if MIM is present, else first chunk before '.'
+    parts = item_name.split(".")
+    if parts[0].startswith("MIM") and len(parts) >= 3:
+        return parts[1]
+    return parts[0]
+
+def infer_device_type(dev: str) -> str:
+    s = dev.lower()
+    if "switch" in s: return "switch"
+    if "inverter" in s: return "inverter"
+    if "diesel" in s or re.search(r"\bgen|generator\b", s): return "generator"
+    if "capacitor" in s or s.startswith("cap_"): return "capacitor"
+    if "regulator" in s or s.startswith("reg_"): return "regulator"
+    if "load" in s: return "load"
+    return "other"
+
+def collect_tags(plan: Dict[str, Any]) -> Dict[str, List[str]]:
+    ops, points, mims, applys, dtypes = set(), set(), set(), set(), set()
+    for it in plan.get("plan", []):
+        ops.add(it.get("op", "set"))
+        points.add(it.get("point", ""))
+        sc = it.get("scope") or {}
+        ap = sc.get("apply", "both")
+        applys.add(ap)
+        mim = sc.get("mim")
+        if mim: mims.add(mim)
+        dev = infer_device_name(it.get("name", ""))
+        dtypes.add(infer_device_type(dev))
+    return {
+        "ops": sorted(x for x in ops if x),
+        "points": sorted(x for x in points if x),
+        "apply": sorted(x for x in applys if x),
+        "mims": sorted(mims),
+        "device_types": sorted(dtypes),
+    }
+
+def item_to_phrase(it: Dict[str, Any]) -> str:
+    # Generate a concise, human prompt fragment for RAG.
+    op = it.get("op", "set")
+    point = it.get("point", "")
+    val = it.get("attack_value", "")
+    nm = infer_device_name(it.get("name", ""))
+    sc = it.get("scope") or {}
+    mim = sc.get("mim")
+    # Normalize value strings a bit
+    sval = str(val)
+    if isinstance(val, float) and sval.endswith(".0"):
+        sval = sval[:-2]
+    # Choose verb template
+    if op in {"open","close","trip"}:
+        base = f"{op} {infer_device_type(nm)} {nm}"
+    elif op in {"increase","decrease","scale"}:
+        base = f"{op} {point} of {nm} by {sval}"
+    else:  # set/default
+        base = f"set {point} of {nm} to {sval}"
+    if mim:
+        base += f" in {mim}"
+    return base
+
+def plan_to_prompt(plan: Dict[str, Any], max_items: int = 6) -> str:
+    items = plan.get("plan", [])[:max_items]
+    if not items:
+        return "Generate an AttackPlan JSON v1.1 (no items)."
+    phrases = [item_to_phrase(it) for it in items]
+    if len(phrases) == 1:
+        return phrases[0]
+    return "; ".join(phrases)
+
+def score(plan: Dict[str, Any]) -> Tuple[int,int,int,int]:
+    """Sort key to promote diversity: favor both/apply, more mims, more ops, more device types."""
+    tags = collect_tags(plan)
+    return (
+        1 if "both" in tags["apply"] else 0,
+        len(tags["mims"]),
+        len(tags["ops"]),
+        len(tags["device_types"]),
+    )
+
+def pick_diverse(plans: List[Dict[str, Any]], k: int, seed: int = 7) -> List[Dict[str, Any]]:
+    rng = random.Random(seed)
+    # Shuffle then sort by our diversity score (descending)
+    rng.shuffle(plans)
+    plans.sort(key=score, reverse=True)
+    # Simple greedy: walk and enforce bucketing caps so we cover ops/apply/points
+    seen_keys = set()
+    picked = []
+    buckets = {}
+    caps = {
+        "apply:glm_only": max(1, k//6),
+        "apply:both": max(1, k//3),
+    }
+    for p in plans:
+        tags = collect_tags(p)
+        key_apply = f"apply:{'glm_only' if 'glm_only' in tags['apply'] else 'both'}"
+        buckets.setdefault(key_apply, 0)
+        if buckets[key_apply] >= caps[key_apply]:
+            continue
+        # de-dup by items signature
+        sig = tuple((it.get("op"), it.get("point"), (it.get("scope") or {}).get("mim")) for it in p.get("plan", [])[:4])
+        if sig in seen_keys:
+            continue
+        seen_keys.add(sig)
+        picked.append(p)
+        buckets[key_apply] += 1
+        if len(picked) >= k:
+            break
+    # If still short, top up ignoring caps
+    i = 0
+    while len(picked) < k and i < len(plans):
+        if plans[i] not in picked:
+            picked.append(plans[i])
+        i += 1
+    return picked[:k]
+
+def write_examples(plans: List[Dict[str, Any]], outdir: Path):
+    outdir.mkdir(parents=True, exist_ok=True)
+    for i, p in enumerate(plans, 1):
+        ex = {
+            "prompt": plan_to_prompt(p),
+            "attack_plan": p,
+            "tags": collect_tags(p)
+        }
+        Path(outdir, f"ex-{i:04d}.json").write_text(json.dumps(ex, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+def write_canonical_snippets(outdir: Path):
+    """A couple of tiny single-item plans as structural references."""
+    outdir.mkdir(parents=True, exist_ok=True)
+    mini = [
+      {
+        "title": "set_inverter_Pref",
+        "plan": {
+          "version": "1.1",
+          "time": {"start_s": 0, "end_s": 30},
+          "mim": {"active": True, "selected": ["MIM2"]},
+          "plan": [{
+            "name": "MIM2.mg1inverter_XXX.Pref",
+            "scope": {"mg": "mg1", "mim":"MIM2", "apply":"both"},
+            "op": "set", "point": "Pref", "attack_value": 10000, "real_value": 0,
+            "phase": None, "window": {"point_start_s": 1, "point_stop_s": 20}
+          }]
+        }
+      },
+      {
+        "title": "open_switch_status",
+        "plan": {
+          "version": "1.1",
+          "time": {"start_s": 0, "end_s": 30},
+          "mim": {"active": True, "selected": ["MIM1"]},
+          "plan": [{
+            "name": "MIM1.mg2microgrid_switch_YYY.status",
+            "scope": {"mg": "mg2", "mim":"MIM1", "apply":"both"},
+            "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED",
+            "phase": None, "window": {"point_start_s": 2, "point_stop_s": 10}
+          }]
+        }
+      },
+      {
+        "title": "glm_only_unmapped_load",
+        "plan": {
+          "version": "1.1",
+          "time": {"start_s": 0, "end_s": 30},
+          "mim": {"active": True, "selected": ["MIM3"]},
+          "plan": [{
+            "name": "load_42.constant_power_A",
+            "scope": {"mg": "unmapped", "mim": None, "apply":"glm_only"},
+            "op": "set", "point": "constant_power_A", "attack_value": 25000, "real_value": 20000,
+            "phase": None, "window": {"point_start_s": 5, "point_stop_s": 25}
+          }]
+        }
+      }
+    ]
+    for m in mini:
+        Path(outdir, f"{m['title']}.json").write_text(json.dumps(m["plan"], ensure_ascii=False, indent=2)+"\n", encoding="utf-8")
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--src", type=str, default="scripts/train_attackplan.jsonl",
+                    help="Path to your AttackPlan JSONL")
+    ap.add_argument("--out", type=str, default="kb/examples",
+                    help="Output folder for RAG examples")
+    ap.add_argument("--k", type=int, default=40,
+                    help="How many examples to write")
+    ap.add_argument("--seed", type=int, default=7)
+    ap.add_argument("--write_snippets", action="store_true",
+                    help="Also write a few canonical mini-plans to kb/snippets/json/")
+    args = ap.parse_args()
+
+    src = Path(args.src)
+    if not src.exists():
+        # Try a couple of common alternate locations
+        candidates = [
+            Path("..") / "EditGlm" / "scripts" / "train_attackplan.jsonl",
+            Path("scripts") / "train_attackplan.jsonl"
+        ]
+        for c in candidates:
+            if c.exists():
+                src = c; break
+
+    print("[seed] reading", src.resolve())
+    plans = load_plans(src)
+    if not plans:
+        raise SystemExit("No valid plans found in JSONL.")
+
+    picked = pick_diverse(plans, k=args.k, seed=args.seed)
+    write_examples(picked, Path(args.out))
+
+    if args.write_snippets:
+        write_canonical_snippets(Path("kb/snippets/json"))
+
+    print(f"[seed] wrote {len(picked)} examples to {Path(args.out).resolve()}")
+    if args.write_snippets:
+        print(f"[seed] wrote canonical mini snippets to {Path('kb/snippets/json').resolve()}")
+
+
+
+if __name__ == "__main__":
+    main()

scripts/split_attackplan_jsonl.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+"""
+split_attackplan_jsonl.py
+Shuffle and split AttackPlan JSONL into datasets/train|val|test.jsonl
+
+Usage:
+  %run scripts/split_attackplan_jsonl.py --src "C:/Users/adetu/Dropbox/Ire_Research/my_code/scripts/train_attackplan.jsonl"
+"""
+from __future__ import annotations
+import argparse, json, random, hashlib
+from pathlib import Path
+
+def plan_sig(plan: dict) -> str:
+  # crude signature to detect duplicates across splits
+  blob = json.dumps(plan.get("plan", []), sort_keys=True)
+  return hashlib.md5(blob.encode("utf-8")).hexdigest()
+
+def main():
+  ap = argparse.ArgumentParser()
+  ap.add_argument("--src", type=str, required=True)
+  ap.add_argument("--seed", type=int, default=7)
+  ap.add_argument("--train", type=float, default=0.70)
+  ap.add_argument("--val", type=float, default=0.15)
+  args = ap.parse_args()
+
+  src = Path(args.src)
+  lines = [ln for ln in src.read_text(encoding="utf-8-sig").splitlines() if ln.strip()]
+  random.Random(args.seed).shuffle(lines)
+
+  n = len(lines)
+  ntr = int(args.train * n)
+  nv = int(args.val * n)
+  test_start = ntr + nv
+
+  outdir = Path("datasets"); outdir.mkdir(exist_ok=True)
+  Path(outdir, "train.jsonl").write_text("\n".join(lines[:ntr]) + "\n", encoding="utf-8")
+  Path(outdir, "val.jsonl").write_text("\n".join(lines[ntr:test_start]) + "\n", encoding="utf-8")
+  Path(outdir, "test.jsonl").write_text("\n".join(lines[test_start:]) + "\n", encoding="utf-8")
+
+  # duplicate signature report
+  import json as _json
+  buckets = {"train":[], "val":[], "test":[]}
+  for name, chunk in [("train", lines[:ntr]), ("val", lines[ntr:test_start]), ("test", lines[test_start:])]:
+    for ln in chunk:
+      try:
+        obj = _json.loads(ln)
+        if isinstance(obj, dict) and "plan" in obj:
+          buckets[name].append(plan_sig(obj))
+      except Exception:
+        pass
+  inter = set(buckets["train"]) & set(buckets["val"]) | set(buckets["train"]) & set(buckets["test"]) | set(buckets["val"]) & set(buckets["test"])
+  print(f"[done] train/val/test = {ntr}/{nv}/{n - ntr - nv}. duplicate_plans_across_splits={len(inter)}")
+
+if __name__ == "__main__":
+  main()

scripts/train_attackplan.filtered.jsonl

@@ -0,0 +1,40 @@
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_1.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 32953.311, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_1.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 26033.967, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_1.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 46037.379, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_2.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 11448.726, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_4.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 41435.28, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_7.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 20148.715, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_7.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 10749.913, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_7.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 18672.914, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_9.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 22794.217, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_12.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 26537.042, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_16.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 24952.078, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_17.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 14464.779, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_19.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 45097.329, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_24.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 35867.219, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_30.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 32339.273, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_30.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 52645.054, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_30.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 27229.055, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_31.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 21632.003, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_32.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 22778.269, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_35.constant_power_A", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 22511.559, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM1.mg1load_39.constant_power_B", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 23607.999, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_41.constant_power_C", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 18551.846, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_42.constant_power_A", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 16282.943, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_42.constant_power_B", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 21711.237, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM1.mg1load_42.constant_power_C", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 19063.688, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_46.constant_power_A", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 23979.889, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM1.mg1load_49.constant_power_A", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 51806.12, "real_value": 35000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_49.constant_power_B", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 43264.604, "real_value": 70000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_49.constant_power_C", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 32134.299, "real_value": 35000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_50.constant_power_A", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 50285.637, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_50.constant_power_B", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 26079.381, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM1.mg1load_50.constant_power_C", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 39558.524, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_51.constant_power_A", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 10784.145, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_51.constant_power_B", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 23364.317, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1load_51.constant_power_C", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 25291.417, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_52.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 42921.038, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_52.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 55019.112, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_52.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 32549.901, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_53.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 47811.815, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_53.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 43774.795, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_53.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 43195.808, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_56.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 19481.967, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_56.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 23283.044, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_56.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 11213.389, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_59.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 22942.577, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_60.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 29861.919, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_60.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 26438.496, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_60.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 15691.911, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_63.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 38467.811, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_63.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 26721.935, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_63.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 24683.832, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_66.constant_power_A", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 43543.598, "real_value": 75000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationload_66.constant_power_B", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 71189.055, "real_value": 75000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationload_66.constant_power_C", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 78707.993, "real_value": 75000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_68.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 27667.677, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_69.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 52771.194, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_70.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 27279.689, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_71.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 31136.843, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3load_73.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 36611.861, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_75.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 55367.713, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3load_761.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 14639.137, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_77.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 29333.443, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_77.constant_power_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 39398.509, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_77.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 43564.94, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3load_80.constant_power_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 17385.071, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_82.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 10663.412, "real_value": 10000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3load_83.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 29061.959, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_84.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 23809.873, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_85.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 40619.657, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_86.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 22351.855, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_86.constant_power_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 23524.002, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3load_86.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 11079.858, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_87.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 55981.32, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_87.constant_power_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 51198.78, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_87.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 54980.527, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_88.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 51914.925, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3load_92.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 35959.153, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_94.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 24141.484, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_95.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 22685.791, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_95.constant_power_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 11244.956, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3load_95.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 11346.952, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_96.constant_power_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 14175.264, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_98.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 26492.128, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_98.constant_power_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 33602.146, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_98.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 22103.024, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3load_99.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 20009.331, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_99.constant_power_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 26050.597, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_99.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 24058.575, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_100.constant_power_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 8.636, "real_value": 10.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3load_100.constant_power_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 13.743, "real_value": 10.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3load_100.constant_power_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 6.486, "real_value": 10.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM2.mg2load_102.constant_power_C", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 16947.791, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM2.mg2load_103.constant_power_C", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 34566.538, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM2.mg2load_104.constant_power_C", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "constant_power_C", "attack_value": 24913.689, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM2.mg2load_106.constant_power_B", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 53957.477, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM2.mg2load_107.constant_power_B", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "constant_power_B", "attack_value": 59724.109, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM2.mg2load_109.constant_power_A", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 38639.578, "real_value": 40000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM2.mg2load_111.constant_power_A", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 19676.693, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM2.mg2load_114.constant_power_A", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "constant_power_A", "attack_value": 16852.717, "real_value": 20000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "unmappedGen1.power_out_A", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "power_out_A", "attack_value": "30000+5000j", "real_value": "30000+3000j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedGen1.power_out_B", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "power_out_B", "attack_value": "60000+12000j", "real_value": "30000+3000j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedGen1.power_out_C", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "power_out_C", "attack_value": "30000+5000j", "real_value": "30000+3000j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedGen2.power_out_A", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "power_out_A", "attack_value": "30000+5000j", "real_value": "25000+8333j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "unmappedGen2.power_out_B", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "power_out_B", "attack_value": "40000+8000j", "real_value": "25000+8333j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedGen2.power_out_C", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "power_out_C", "attack_value": "60000+12000j", "real_value": "25000+8333j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3Gen3.Qref", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "Qref", "attack_value": 2.38, "real_value": 2.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3Gen3.power_out_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "power_out_A", "attack_value": "30000+5000j", "real_value": "50000+16667j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3Gen3.power_out_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "power_out_B", "attack_value": "40000+8000j", "real_value": "50000+16667j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3Gen3.power_out_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "power_out_C", "attack_value": "30000+5000j", "real_value": "50000+16667j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedGen4.power_out_A", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "power_out_A", "attack_value": "30000+5000j", "real_value": "50000+16667j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedGen4.power_out_B", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "power_out_B", "attack_value": "40000+8000j", "real_value": "50000+16667j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "unmappedGen4.power_out_C", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "power_out_C", "attack_value": "30000+5000j", "real_value": "50000+16667j", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1trip_shad_inv1.Pref", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "Pref", "attack_value": 390014.906, "real_value": 450000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1trip_shad_inv1.Qref", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "Qref", "attack_value": 6670.42, "real_value": 0.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedtrip_shad_inv2.Pref", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "Pref", "attack_value": 160264.176, "real_value": 126000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedtrip_shad_inv2.Qref", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "Qref", "attack_value": 10325.924, "real_value": 0.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM2.mg2trip_shad_inv3.Pref", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "Pref", "attack_value": 107440.611, "real_value": 84000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM2.mg2trip_shad_inv3.Qref", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "Qref", "attack_value": 8296.65, "real_value": 0.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1trip_shad_inv4.Pref", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "Pref", "attack_value": 151838.751, "real_value": 210000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM1.mg1trip_shad_inv4.Qref", "scope": {"mg": "mg1", "mim": "MIM1", "apply": "both"}, "op": "set", "point": "Qref", "attack_value": 13115.112, "real_value": 0.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "unmappedtrip_shad_inv5.Pref", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "Pref", "attack_value": 405788.64, "real_value": 300000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedtrip_shad_inv5.Qref", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "Qref", "attack_value": 13060.786, "real_value": 0.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedtrip_shad_inv6.Pref", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "Pref", "attack_value": 86791.111, "real_value": 70000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "unmappedtrip_shad_inv6.Qref", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "Qref", "attack_value": 7267.395, "real_value": 0.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM4.substationmicrogrid_switch0.status", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3switch_76-86.status", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3switch_76-761.status", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationmicrogrid_switch1.status", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3microgrid_switch2.status", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationmicrogrid_switch3.status", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM2.mg2microgrid_switch4.status", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationswitch_13-152.status", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationswitch_61-611.status", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "unmappedswitch_1491-149.status", "scope": {"mg": "unmapped", "mim": null, "apply": "glm_only"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationswitch_250-251.status", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3switch_450-451.status", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM4.substationswitch_54-94.status", "scope": {"mg": "substation", "mim": "MIM4", "apply": "both"}, "op": "set", "point": "status", "attack_value": "CLOSED", "real_value": "OPEN", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM2.mg2switch_300-350.status", "scope": {"mg": "mg2", "mim": "MIM2", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3switch_95-195.status", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3switch_100-101.status", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "status", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_83.switchA", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "switchA", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_83.switchB", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "switchB", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_83.switchC", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "switchC", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3cap_83.capacitor_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "capacitor_A", "attack_value": 171112.509, "real_value": 200000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_83.capacitor_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "capacitor_B", "attack_value": 105796.03, "real_value": 200000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_83.capacitor_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "capacitor_C", "attack_value": 105587.415, "real_value": 200000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_88.switchA", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "switchA", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_88.capacitor_A", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "capacitor_A", "attack_value": 38970.927, "real_value": 50000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}
+{"version": "1.1", "time": {"start_s": 0.0, "end_s": 60.0}, "mim": {"active": true, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]}, "plan": [{"name": "MIM3.mg3cap_90.switchB", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "switchB", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_90.capacitor_B", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "capacitor_B", "attack_value": 37958.718, "real_value": 50000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_92.switchC", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "switchC", "attack_value": "OPEN", "real_value": "CLOSED", "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}, {"name": "MIM3.mg3cap_92.capacitor_C", "scope": {"mg": "mg3", "mim": "MIM3", "apply": "both"}, "op": "set", "point": "capacitor_C", "attack_value": 59626.097, "real_value": 50000.0, "phase": null, "window": {"point_start_s": 1.0, "point_stop_s": 20.0}}], "compile_hints": {"scenario_id": "a"}}

scripts/train_attackplan.jsonl

@@ -0,0 +1,269 @@
+from __future__ import annotations
+"""
+Created on Sun Aug 17 19:47:52 2025
+
+@author: adetu
+"""
+
+# -*- coding: utf-8 -*-
+"""
+make_train_jsonl.py  —  builds training JSONL for AttackPlan v1.1 (and a chat sample)
+
+Outputs (saved two folders above your workspace, under scripts/):
+  - train_attackplan.jsonl   # one AttackPlan v1.1 per line
+  - train_chat.jsonl         # one chat-style example (system/user -> assistant JSON)
+  - train_preview.csv        # quick preview of first ~30 items
+
+Run (from EditGlm/ as CWD):
+  %run scripts/make_train_jsonl.py --n 400 --seed 7
+"""
+
+import argparse, json, os, random, sys
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+
+import pandas as pd
+
+
+sys.path.insert(0, os.getcwd())
+
+# Your libs
+from libraries import BikdashGLM as BG
+from libraries import IreNatJson as INJ
+
+ATTACKPLAN_VERSION = "1.1"
+
+
+# Filesystem helpers
+
+def _folders_files(Remarks: dict):
+    res = BG.FoldersAndFiles(Remarks)
+    if isinstance(res, tuple):
+        if len(res) == 2:
+            Folders, Files = res
+            return Folders, Files, Remarks
+        elif len(res) == 3:
+            Folders, Files, Remarks = res
+            return Folders, Files, Remarks
+    raise RuntimeError("Unexpected return from BG.FoldersAndFiles(Remarks)")
+
+def _read_initial_glm(Files: dict) -> str:
+    with open(Files["initialGlm"], "r", encoding="utf-8") as f:
+        return f.read()
+
+def _load_ngj(Files: dict) -> dict:
+    """Load/parse your combined JSON into NGJ and expand mg lookup."""
+    json_text = Path(Files["combinedJson"]).read_text(encoding="utf-8")
+    ng = INJ.parse_ngjson(Files, json_text)
+    NGJ = INJ.getNGJ(ng)
+    BG.expand_mg_info(NGJ)  # builds mg_device_lookup, etc.
+    return NGJ
+
+def _build_topology(ELEMglm: dict, Topol: dict, NGJ: dict) -> dict:
+    BG.getTopol(ELEMglm, Topol)
+    Topol["mg_device_lookup"] = NGJ.get("mg_device_lookup", {})
+    Topol.update(INJ.microgrid_mapping(NGJ))  # adds mg_map, etc.
+    return Topol
+
+def _scope_map_from_topol_and_glm(Topol: dict, ELEMglm: dict) -> Dict[str, Dict[str, str | None]]:
+    """device -> {'mg': 'mg1|mg2|mg3|substation|unmapped', 'mim': 'MIM1'..'MIM4'|None}"""
+    scope = {}
+    mg_map: Dict[str, Dict[str, str]] = Topol.get("mg_map", {}) or {}
+    objTypes = ['switch', 'load', 'inverter_dyn', 'diesel_dg', 'capacitor', 'regulator']
+    try:
+        names, _ = BG.extractNamesTypes(ELEMglm, objTypes)
+    except Exception:
+        names = []
+        for t in objTypes:
+            for blk in ELEMglm.get(t, []):
+                try:
+                    nm = BG.extractNameOfGlmObject(blk)
+                    if nm: names.append(nm)
+                except Exception:
+                    pass
+    names = list(dict.fromkeys(names))
+    for dev in names:
+        ent = mg_map.get(dev)
+        if isinstance(ent, dict) and ent.get("mg") and ent.get("mim"):
+            scope[dev] = {"mg": ent["mg"], "mim": ent["mim"]}
+        else:
+            scope[dev] = {"mg": "unmapped", "mim": None}
+    return scope
+
+def _name_from_scope(dev: str, prop: str, scope: Dict[str, Dict[str, str | None]]) -> str:
+    """Build 'MIMx.mgDevice.property' if mapped; else 'mg?Device.property' (schema allows missing MIM)."""
+    ent = scope.get(dev, {"mg": "unmapped", "mim": None})
+    mg = ent.get("mg") or "unmapped"
+    mim = ent.get("mim")
+    base = f"{mg}{dev}.{prop}"
+    return f"{mim}.{base}" if mim else base
+
+def _window_default() -> Dict[str, float]:
+    return {"point_start_s": 1.0, "point_stop_s": 20.0}
+
+def _attackplan_skeleton() -> Dict[str, Any]:
+    return {
+        "version": ATTACKPLAN_VERSION,
+        "time": {"start_s": 0.0, "end_s": 60.0},
+        "mim": {"active": True, "selected": ["MIM1", "MIM2", "MIM3", "MIM4"]},
+        "plan": [],
+        "compile_hints": {"scenario_id": "a"}
+    }
+
+# Value transforms (local)
+
+def _flip_status(val: Any) -> str:
+    s = str(val).strip().lower()
+    if s in {"open", "0", "false", "off"}:   return "CLOSED"
+    if s in {"closed", "1", "true", "on"}:   return "OPEN"
+    return "OPEN" if "open" not in s else "CLOSED"
+
+def _to_float(val: Any) -> float | None:
+    try:
+        return float(val)
+    except Exception:
+        return None
+
+def _rand_scale(num: float, rng: random.Random) -> float:
+    # scale in [0.5, 1.5]  (adjust if you prefer)
+    return num * rng.uniform(0.5, 1.5)
+
+# Main item builder (uses INJ.extract_baseline)
+
+def _items_from_baseline(ELEMglm: dict,
+                         scope_lookup: Dict[str, Dict[str, str | None]],
+                         n: int | None = None,
+                         seed: int = 7) -> List[Dict[str, Any]]:
+    """
+    Use IreNatJson.extract_baseline(ELEMglm) to get {(device, prop): value} and dev types,
+    then create AttackPlan v1.1 plan items by flipping status / tweaking numeric values.
+    """
+    rng = random.Random(seed)
+    baseline, dev_type = INJ.extract_baseline(ELEMglm)  # returns dict, dict
+
+    # Optional downsample
+    pairs = list(baseline.items())
+    if n is not None and n > 0 and len(pairs) > n:
+        rng.shuffle(pairs)
+        pairs = pairs[:n]
+
+    items: List[Dict[str, Any]] = []
+    for (device_name, property_name), original_val in pairs:
+        # Decide new value
+        if property_name.lower() in {"status", "switcha", "switchb", "switchc"}:
+            new_val = _flip_status(original_val)
+        elif str(property_name).startswith("power_out_"):  # generator complex literals
+            new_val = rng.choice(["60000+12000j", "40000+8000j", "30000+5000j"])
+        else:
+            num = _to_float(original_val)
+            if num is None:
+                # fallback if unparsable numeric — skip this property
+                continue
+            # Prefer not to keep 0 for inverter Pref/Qref → give a small nonzero base
+            if (dev_type.get(device_name, "").startswith("inverter")
+                and property_name in ("Pref", "Qref") and num == 0):
+                num = 10000.0  # adjust if you have a domain-specific default
+            new_val = round(_rand_scale(num, rng), 3)
+
+        # Build plan item
+        name = _name_from_scope(device_name, property_name, scope_lookup)
+        ent = scope_lookup.get(device_name, {"mg": "unmapped", "mim": None})
+        scope = {"mg": ent.get("mg"), "mim": ent.get("mim"), "apply": "both" if ent.get("mim") else "glm_only"}
+        item = {
+            "name": name,
+            "scope": scope,
+            "op": "set",                         # normalized; compiler can map to open/close/trip later
+            "point": property_name,
+            "attack_value": new_val,
+            "real_value": original_val,
+            "phase": None,
+            "window": _window_default(),
+        }
+        items.append(item)
+    return items
+
+# Output packers
+
+def _chat_pair_from_items(items: List[Dict[str, Any]]) -> Dict[str, Any]:
+    plan = _attackplan_skeleton()
+    plan["plan"] = items
+    return {
+        "messages": [
+            {"role": "system", "content": "You output ONLY JSON, no explanation."},
+            {"role": "user", "content": "Generate an AttackPlan JSON v1.1 for the following actions. Respect microgrid scope; if a device is unmapped, mark it glm_only. Return ONLY the JSON."},
+            {"role": "assistant", "content": json.dumps(plan, ensure_ascii=False)}
+        ]
+    }
+
+def _attackplan_lines_from_items(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    lines = []
+    pack = 5  # 3–6 items per plan; adjust as you like
+    for i in range(0, len(items), pack):
+        plan = _attackplan_skeleton()
+        plan["plan"] = items[i:i+pack]
+        if plan["plan"]:
+            lines.append(plan)
+    return lines
+
+# Main
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--n", type=int, default=400, help="Max number of (device,property) pairs to sample.")
+    ap.add_argument("--seed", type=int, default=7)
+    args = ap.parse_args()
+
+    Remarks = BG.initRemarks()
+    Folders, Files, Remarks = _folders_files(Remarks)
+
+    # Output root: two folders above workspace, into scripts/
+    ws = Path(Folders["workspace"]).resolve()
+    out_root = ws.parents[1] / "scripts"
+    out_root.mkdir(parents=True, exist_ok=True)
+
+    # Load inputs
+    initialGlm = _read_initial_glm(Files)
+    ELEMglm, Topol = BG.getELEMs(Files, initialGlm)
+    NGJ = _load_ngj(Files)
+    Topol = _build_topology(ELEMglm, Topol, NGJ)
+    scope_lookup = _scope_map_from_topol_and_glm(Topol, ELEMglm)
+
+    # Build items using IreNatJson.extract_baseline
+    items = _items_from_baseline(ELEMglm, scope_lookup, n=args.n, seed=args.seed)
+
+    # Pack outputs
+    chat_line = _chat_pair_from_items(items[:min(25, len(items))])
+    plan_lines = _attackplan_lines_from_items(items)
+
+    # Write
+    attackplan_path = out_root / "train_attackplan.jsonl"
+    chat_path = out_root / "train_chat.jsonl"
+    preview_path = out_root / "train_preview.csv"
+
+    with attackplan_path.open("w", encoding="utf-8") as f:
+        for plan in plan_lines:
+            f.write(json.dumps(plan, ensure_ascii=False) + "\n")
+
+    with chat_path.open("w", encoding="utf-8") as f:
+        f.write(json.dumps(chat_line, ensure_ascii=False) + "\n")
+
+    preview = [{
+        "name": it["name"],
+        "mg": (it.get("scope") or {}).get("mg"),
+        "mim": (it.get("scope") or {}).get("mim"),
+        "apply": (it.get("scope") or {}).get("apply"),
+        "op": it["op"],
+        "point": it["point"],
+        "attack_value": it["attack_value"],
+        "real_value": it["real_value"],
+        "start": it["window"]["point_start_s"],
+        "stop": it["window"]["point_stop_s"],
+    } for it in items[:30]]
+    pd.DataFrame(preview).to_csv(preview_path, index=False)
+
+    print(f"[ok] wrote {attackplan_path}")
+    print(f"[ok] wrote {chat_path}")
+    print(f"[ok] wrote {preview_path}")
+
+if __name__ == "__main__":
+    main()

scripts/train_qlora.py

@@ -0,0 +1,226 @@
+# train_qlora.py
+# QLoRA fine tuning for chat JSONL built from attack plans
+# Works well with deepseek-ai/deepseek-coder-6.7b-instruct on Colab Pro GPUs
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Dict, List, Union
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    BitsAndBytesConfig,
+    Trainer,
+    TrainingArguments,
+)
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--base", type=str, required=True, help="Base model id or path")
+    ap.add_argument("--data", type=str, required=True, help="JSONL with chat messages")
+    ap.add_argument("--out", type=str, required=True, help="Output dir for adapter")
+    ap.add_argument("--epochs", type=int, default=2)
+    ap.add_argument("--bsz", type=int, default=8)
+    ap.add_argument("--grad_accum", type=int, default=1)
+    ap.add_argument("--cutoff_len", type=int, default=2048)
+    ap.add_argument("--lr", type=float, default=2e-4)
+    ap.add_argument("--lora_r", type=int, default=16)
+    ap.add_argument("--lora_alpha", type=int, default=32)
+    ap.add_argument("--lora_dropout", type=float, default=0.05)
+    ap.add_argument("--debug", action="store_true")
+    return ap.parse_args()
+
+
+def device_supports_bf16() -> bool:
+    if not torch.cuda.is_available():
+        return False
+    major, _ = torch.cuda.get_device_capability(0)
+    return major >= 8  # Ampere or newer
+
+
+def build_tokenizer(base_id: str):
+    tok = AutoTokenizer.from_pretrained(base_id, use_fast=True)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    tok.padding_side = "right"
+    return tok
+
+
+def _to_ids(x: Union[torch.Tensor, List[int], Dict[str, List[int]]]) -> List[int]:
+    if isinstance(x, torch.Tensor):
+        return x.detach().cpu().tolist()[0] if x.ndim == 2 else x.detach().cpu().tolist()
+    if isinstance(x, dict) and "input_ids" in x:
+        return x["input_ids"]
+    if isinstance(x, (list, tuple)):
+        return list(x)
+    raise TypeError(f"Unsupported chat template return type: {type(x)}")
+
+
+def chat_to_ids(tokenizer: AutoTokenizer, messages: List[Dict], max_len: int):
+    # Prefer native chat template. In recent Transformers this returns a tensor
+    # when return_tensors is set, or a list of token ids when tokenize is True.
+    if hasattr(tokenizer, "apply_chat_template") and tokenizer.chat_template:
+        out = tokenizer.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=False,
+            return_tensors="pt",
+            max_length=max_len,
+            truncation=True,
+        )
+        ids = _to_ids(out)
+        attn = [1] * len(ids)
+        return {"input_ids": ids, "attention_mask": attn}
+
+    # Fallback when no chat template is available
+    lines = []
+    for m in messages:
+        role = m.get("role", "user")
+        content = m.get("content", "")
+        lines.append(f"{role}:\n{content}\n")
+    text = "\n".join(lines)
+    enc = tokenizer(text, max_length=max_len, truncation=True)
+    return {"input_ids": enc["input_ids"], "attention_mask": enc["attention_mask"]}
+
+
+def collate_pad(tokenizer: AutoTokenizer):
+    pad_id = tokenizer.pad_token_id
+
+    def _fn(batch: List[Dict[str, List[int]]]):
+        max_len = max(len(x["input_ids"]) for x in batch)
+        input_ids, attn, labels = [], [], []
+        for x in batch:
+            ids = x["input_ids"]
+            am = x["attention_mask"]
+            pad_n = max_len - len(ids)
+            input_ids.append(ids + [pad_id] * pad_n)
+            attn.append(am + [0] * pad_n)
+            labels.append(ids + [-100] * pad_n)
+        return {
+            "input_ids": torch.tensor(input_ids, dtype=torch.long),
+            "attention_mask": torch.tensor(attn, dtype=torch.long),
+            "labels": torch.tensor(labels, dtype=torch.long),
+        }
+
+    return _fn
+
+
+def guess_lora_targets(model: torch.nn.Module) -> List[str]:
+    prefs = [
+        "q_proj",
+        "k_proj",
+        "v_proj",
+        "o_proj",
+        "gate_proj",
+        "up_proj",
+        "down_proj",
+        "wi",
+        "wo",
+        "w1",
+        "w2",
+        "w3",
+        "out_proj",
+    ]
+    found = set()
+    for name, _ in model.named_modules():
+        for p in prefs:
+            if p in name:
+                found.add(p)
+    return sorted(found) if found else ["Linear"]
+
+
+def main():
+    args = parse_args()
+    base_id = args.base
+    data_path = Path(args.data)
+    out_dir = Path(args.out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    tokenizer = build_tokenizer(base_id)
+
+    ds = load_dataset("json", data_files=str(data_path), split="train")
+
+    def map_row(ex):
+        return chat_to_ids(tokenizer, ex["messages"], args.cutoff_len)
+
+    # Remove original columns after mapping so only model fields remain
+    ds = ds.map(map_row, remove_columns=ds.column_names)
+
+    collate = collate_pad(tokenizer)
+
+    quant = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_use_double_quant=True,
+    )
+
+    use_bf16 = device_supports_bf16()
+    torch_dtype = torch.bfloat16 if use_bf16 else torch.float16
+    torch.backends.cuda.matmul.allow_tf32 = True
+
+    model = AutoModelForCausalLM.from_pretrained(
+        base_id,
+        device_map="auto",
+        quantization_config=quant,
+        torch_dtype=torch_dtype,
+    )
+
+    model = prepare_model_for_kbit_training(model)
+    lconf = LoraConfig(
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        bias="none",
+        task_type="CAUSAL_LM",
+        target_modules=guess_lora_targets(model),
+    )
+    model = get_peft_model(model, lconf)
+
+    train_args = TrainingArguments(
+        output_dir=str(out_dir),
+        num_train_epochs=args.epochs,
+        per_device_train_batch_size=args.bsz,
+        gradient_accumulation_steps=args.grad_accum,
+        learning_rate=args.lr,
+        lr_scheduler_type="cosine",
+        warmup_ratio=0.03,
+        logging_steps=5,
+        save_steps=100,
+        bf16=use_bf16,
+        fp16=not use_bf16,
+        optim="paged_adamw_8bit",
+        remove_unused_columns=False,
+        dataloader_num_workers=2,
+        report_to=[],
+    )
+
+    tr = Trainer(
+        model=model,
+        args=train_args,
+        train_dataset=ds,
+        data_collator=collate,
+        tokenizer=tokenizer,
+    )
+
+    if args.debug:
+        batch = next(iter(tr.get_train_dataloader()))
+        print("[debug] batch keys:", list(batch.keys()))
+        for k, v in batch.items():
+            if isinstance(v, torch.Tensor):
+                print(f"[debug] {k}: shape={tuple(v.shape)} dtype={v.dtype}")
+
+    tr.train()
+
+    model.save_pretrained(str(out_dir))
+    tokenizer.save_pretrained(str(out_dir))
+    print("[ok] saved adapter to", out_dir.resolve())
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_attackplan_jsonl.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Aug 17 20:36:17 2025
+
+@author: adetu
+"""
+
+import json, sys
+from json import JSONDecodeError
+from pathlib import Path
+from jsonschema import Draft202012Validator as V
+
+def load_schema():
+    candidates = [
+        Path("schemas/attack_plan.schema.json"),
+        Path("../schemas/attack_plan.schema.json"),
+    ]
+    for p in candidates:
+        if p.exists():
+            raw = p.read_text(encoding="utf-8-sig")  # handle BOM
+            # strip accidental markdown fences
+            lines = [ln for ln in raw.splitlines() if not ln.strip().startswith("```")]
+            raw = "\n".join(lines).strip()
+            if not raw:
+                raise RuntimeError(f"Schema file is empty: {p}")
+            try:
+                schema = json.loads(raw)
+                print(f"[schema] loaded {p.resolve()}")
+                return schema
+            except JSONDecodeError as e:
+                ctx = raw.splitlines()[max(e.lineno-2,0):e.lineno+1]
+                print(f"[schema] JSON error in {p}: {e.msg} at line {e.lineno}, col {e.colno}")
+                print("Context:\n" + "\n".join(ctx))
+                raise
+    raise FileNotFoundError("Could not find schema at schemas/attack_plan.schema.json")
+
+def main():
+    schema = load_schema()
+    validator = V(schema)
+
+    src = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("scripts/train_attackplan.jsonl")
+    raw = src.read_text(encoding="utf-8")
+    valid = invalid = 0
+    for i, line in enumerate(raw.splitlines(), 1):
+        if not line.strip():  # skip blanks
+            continue
+        try:
+            obj = json.loads(line)
+        except JSONDecodeError as e:
+            print(f"[line {i}] not JSON: {e.msg} at {e.lineno}:{e.colno}")
+            print(" snippet:", line[:200])
+            invalid += 1
+            continue
+
+        errs = sorted(validator.iter_errors(obj), key=lambda e: (list(e.path), e.message))
+        if errs:
+            invalid += 1
+            print(f"[line {i}] INVALID:")
+            for e in errs[:8]:
+                print("  -", e.message, "at", list(e.path))
+        else:
+            valid += 1
+    print(f"[done] {valid} valid, {invalid} invalid")
+
+if __name__ == "__main__":
+    main()

scripts/write_glm_snippets.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+"""
+write_glm_snippets.py
+Write a few canonical GLM snippets under kb/snippets/glm for reference.
+These are small, human-readable examples — not full runnable feeders.
+
+Usage:
+  %run scripts/write_glm_snippets.py
+"""
+from pathlib import Path
+
+SNIPS = {
+  "open_switch_status.glm": r"""// Minimal switch example (OPEN)
+object switch {
+  name microgrid_switch_YYY;
+  status OPEN;  // CLOSE to reconnect
+}
+""",
+  "close_switch_status.glm": r"""// Minimal switch example (CLOSED)
+object switch {
+  name microgrid_switch_YYY;
+  status CLOSED;
+}
+""",
+  "set_inverter_Pref_Qref.glm": r"""// Inverter real/reactive setpoints (values indicative)
+object inverter_dyn {
+  name inverter_XXX;
+  Pref 10000;    // [W]
+  Qref 0;        // [var]
+  // Pmax 50000; // [W] (if present in your models)
+  // Qmax 30000; // [var]
+  // Vset 4800;  // [mV] or [V] depending on your modeling (verify in your pipeline)
+}
+""",
+  "set_load_constant_power_A.glm": r"""// Load constant power (phase A)
+object load {
+  name load_41;
+  constant_power_A 25000; // [VA], can be complex like 60000+12000j
+}
+""",
+  "set_generator_power_out.glm": r"""// Diesel generator phase power outputs
+object diesel_dg {
+  name gen_01;
+  power_out_A 60000+12000j; // [VA], complex
+  // power_out_B 40000+8000j;
+  // power_out_C 30000+5000j;
+}
+""",
+  "set_capacitor_phase.glm": r"""// Capacitor phase state/setting (model-specific)
+object capacitor {
+  name cap_01;
+  // Some models use per-phase flags or discrete steps; confirm with your code.
+  // Examples (choose one representation your pipeline expects):
+  // capacitor_A CLOSED;
+  // capacitor_B OPEN;
+  // capacitor_C CLOSED;
+}
+""",
+  "set_regulator_tap.glm": r"""// Regulator tap steps (example)
+object regulator {
+  name reg_01;
+  tap_A 3;  // integer step
+  tap_B 2;
+  tap_C 4;
+}
+""",
+  "README.md": r"""These snippets are tiny GLM fragments used as **reference** for RAG.
+They are not full feeders. Use them to:
+- ground the LLM on property spellings and typical values,
+- show OPEN/CLOSED vs numeric edits,
+- remind how inverter/load/generator/regulator properties look in GLM.
+
+**REALITY FILTER**:
+- Where semantics are unclear, this folder includes comments marked [Inference] or asks you to verify in your pipeline.
+- Prefer your actual GLM corpus (via RAG) for precise formatting when available.
+"""
+}
+
+def main():
+  outdir = Path("kb/snippets/glm")
+  outdir.mkdir(parents=True, exist_ok=True)
+  for fname, text in SNIPS.items():
+    (outdir / fname).write_text(text.strip() + "\n", encoding="utf-8")
+  print("[ok] wrote", len(SNIPS), "files to", outdir.resolve())
+
+if __name__ == "__main__":
+  main()