@heretek-ai/epistemic-swarm 0.2.2 → 0.3.0

package/scripts/auction_experiment.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""
+Stream F / Frontier Markets probe harness.
+
+Probe: [HYPOTHESIS: on a fixed 4-scope objective, auction allocation matches
+static-DAG wall-clock and yields >= 20% more distinct verified claims per
+token]
+
+Runs the same fixed objective twice — once with allocation="dag", once with
+allocation="auction" — and emits a comparison artifact under
+.research/experiments/. LIVE MODE SPENDS MONEY; use --mock to prove the
+harness (the probe itself requires real models).
+
+Token accounting is a chars/4 ESTIMATE (flagged approximation) — report both
+chars and tokens in the artifact.
+
+Usage:
+  python3 scripts/auction_experiment.py --mock          # harness proof
+  python3 scripts/auction_experiment.py                 # live probe run
+"""
+
+import argparse
+import contextlib
+import io
+import json
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from runner.auctioneer import estimate_tokens  # noqa: E402
+from runner.research_swarm import SwarmRunner  # noqa: E402
+
+FIXTURE = PROJECT_ROOT / "runner" / "tests" / "fixtures" / "auction_objective.json"
+GATE_BAR_CLAIMS_PER_TOKEN = 0.20
+
+
+def load_fixture(path: Path = FIXTURE) -> Dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def run_once(
+    fixture: Dict[str, Any],
+    base_dir: Path,
+    allocation: str,
+    mock: bool,
+) -> Dict[str, Any]:
+    """One full swarm run under one allocation policy. Returns metrics."""
+    # Seed a fixed 4-scope manifest by pre-writing the scope list through a
+    # stub orchestrator: we pass scopes via a tiny monkeypatch so both arms
+    # see the IDENTICAL scope set (fair comparison).
+    runner = SwarmRunner(base_dir=base_dir, mock_mode=mock, allocation=allocation)
+
+    fixed_scopes = fixture["scopes"]
+
+    def fixed_orchestrate(objective, frontier_file=None):
+        runner.state_machine.init_session(objective)
+        runner.state_machine.set_scopes(fixed_scopes)
+        return fixed_scopes
+
+    runner.orchestrate_objective = fixed_orchestrate  # type: ignore[method-assign]
+
+    buf = io.StringIO()
+    started = time.perf_counter()
+    with contextlib.redirect_stdout(buf):
+        runner.run_swarm(fixture["objective"])
+    elapsed = time.perf_counter() - started
+
+    # Metrics from scope manifests + audit reports.
+    total_chars = 0
+    total_tokens_est = 0
+    verified = 0
+    for s in fixed_scopes:
+        sid = s["scope_id"]
+        scope_dir = base_dir / "scratchpads" / sid
+        for name in ("alpha_dossier.json", "beta_dossier.json"):
+            p = scope_dir / name
+            if p.exists():
+                total_chars += p.stat().st_size
+        audit_path = scope_dir / "audit_report.json"
+        if audit_path.exists():
+            try:
+                summary = json.loads(audit_path.read_text()).get("summary", {})
+                verified += int(summary.get("verified_passed", 0))
+            except (OSError, json.JSONDecodeError):
+                pass
+        manifest_path = scope_dir / "manifest.json"
+        if manifest_path.exists():
+            try:
+                telemetry = json.loads(manifest_path.read_text()).get("telemetry", {})
+                if "tokens_used" in telemetry:
+                    total_tokens_est += int(telemetry["tokens_used"])
+            except (OSError, json.JSONDecodeError):
+                pass
+
+    if total_tokens_est == 0:
+        total_tokens_est = estimate_tokens("x" * total_chars)
+
+    return {
+        "allocation": allocation,
+        "wall_clock_s": round(elapsed, 3),
+        "verified_claims": verified,
+        "chars": total_chars,
+        "tokens_estimate": total_tokens_est,  # FLAGGED APPROXIMATION (chars/4)
+        "claims_per_token": (
+            round(verified / total_tokens_est, 6) if total_tokens_est else None
+        ),
+    }
+
+
+def main(argv: Optional[list] = None) -> int:
+    parser = argparse.ArgumentParser(description="Stream F auction experiment")
+    parser.add_argument("--mock", action="store_true", help="Mock mode, zero API cost")
+    parser.add_argument("--out-dir", default=None)
+    parser.add_argument("--fixture", default=str(FIXTURE))
+    args = parser.parse_args(argv)
+
+    fixture = load_fixture(Path(args.fixture))
+    out_dir = Path(args.out_dir) if args.out_dir else (PROJECT_ROOT / ".research" / "experiments")
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    results = {}
+    for policy in ("dag", "auction"):
+        print(f"[{policy}] run...", flush=True)
+        results[policy] = run_once(
+            fixture, out_dir / "work" / f"auction_{policy}", policy, args.mock
+        )
+
+    dag, auction = results["dag"], results["auction"]
+    wall_ratio = (
+        round(auction["wall_clock_s"] / dag["wall_clock_s"], 4)
+        if dag["wall_clock_s"] > 0 else None
+    )
+    cpt_gain = (
+        round((auction["claims_per_token"] - dag["claims_per_token"]) / dag["claims_per_token"], 4)
+        if dag["claims_per_token"] else None
+    )
+
+    if args.mock:
+        gate = "UNMEASURED_MOCK"
+    elif cpt_gain is None:
+        gate = "UNMEASURED"
+    else:
+        gate = "PASS" if cpt_gain >= GATE_BAR_CLAIMS_PER_TOKEN else "FAIL"
+
+    artifact = {
+        "experiment": "auction-f",
+        "ran_at": datetime.now(timezone.utc).isoformat(),
+        "mock": args.mock,
+        "fixture": args.fixture,
+        "gate_bar_claims_per_token_gain": GATE_BAR_CLAIMS_PER_TOKEN,
+        "results": results,
+        "wall_clock_ratio_auction_over_dag": wall_ratio,
+        "claims_per_token_gain": cpt_gain,
+        "gate_f": gate,
+        "token_note": "tokens_estimate is chars/4 — a flagged approximation, not a measurement",
+    }
+
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    out_path = out_dir / f"auction_{stamp}.json"
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(artifact, f, indent=2)
+
+    print(json.dumps({
+        "gate_f": gate,
+        "claims_per_token_gain": cpt_gain,
+        "wall_clock_ratio": wall_ratio,
+        "artifact": str(out_path),
+    }, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/build_adapters.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""
+IUMBTEMS Universal Harness Adapter builder.
+
+Single canonical source of truth: skills/*/SKILL.md + prompts/*.md.
+Since the MCP-canonical migration (Stream A2b), harness mirrors are THIN STUBS,
+not code copies: each target skill dir holds one ~10-line SKILL.md pointing at
+the canonical prose (skills/<skill>/) and the canonical programmatic surface
+(runner/mcp_server.py). Full skill copies were retired deliberately — see
+.research/scratchpads/brainstorm_where-do-we-go-from-here/g1_probe.md.
+
+Targets (each gets one stub per canonical skill):
+  plugins/antigravity/skills/<skill>/SKILL.md
+  plugins/gemini/skills/<skill>/SKILL.md
+  plugins/codex/skills/<skill>/SKILL.md
+  .agents/skills/<skill>/SKILL.md
+
+Also validates every manifest referenced in package.json pi/omp blocks.
+
+Usage:
+  python3 scripts/build_adapters.py            # build all stubs
+  python3 scripts/build_adapters.py --check     # verify stubs match template (CI)
+  python3 scripts/build_adapters.py --clean     # remove generated stubs
+"""
+
+import argparse
+import json
+import shutil
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+CANONICAL_SKILLS = [
+    "grilling",
+    "research_cache",
+    "epistemic_search",
+    "swarm_config",
+    "code_audit",
+    "oss_scout",
+    "brainstorming",
+]
+
+# Skill -> the MCP tool(s) that now carry its programmatic surface.
+SKILL_TOOLS = {
+    "grilling": ["iumbtems_socratic_frontier"],
+    "research_cache": ["iumbtems_verify_quote"],
+    "epistemic_search": ["brave_web_search / firecrawl_scrape (research MCP servers)"],
+    "swarm_config": ["iumbtems_config"],
+    "code_audit": ["iumbtems_code_audit"],
+    "oss_scout": ["iumbtems_oss_scout"],
+    "brainstorming": ["iumbtems_brainstorm"],
+}
+
+SKILL_TITLES = {
+    "grilling": "Socratic Grilling",
+    "research_cache": "Research Cache",
+    "epistemic_search": "Epistemic Search",
+    "swarm_config": "Swarm Config",
+    "code_audit": "Code Audit",
+    "oss_scout": "OSS Scout",
+    "brainstorming": "Brainstorming",
+}
+
+# (target dir relative to root, mode). All targets are stubs since A2b.
+TARGETS = [
+    ("plugins/antigravity/skills", "stub"),
+    ("plugins/gemini/skills", "stub"),
+    ("plugins/codex/skills", "stub"),
+    (".agents/skills", "stub"),
+]
+
+STUB_TEMPLATE = """# {title} (thin adapter stub)
+
+This file is a POINTER, not the implementation. It exists so harness skill
+discovery finds an entry; the real skill lives in the IUMBTEMS repo.
+
+- Canonical prose & scripts: `skills/{skill}/`
+- Canonical programmatic surface: `python3 runner/mcp_server.py` (stdio MCP),
+  or one-shot: `python3 runner/mcp_server.py call <tool> '{{...json...}}'`
+- MCP tools for this skill: {tools}
+
+Epistemic rules apply regardless of harness: tag claims as
+`[VERIFIED: <hash>]`, `[INFERRED: <reasoning>]`, `[HYPOTHESIS: <test>]`, or
+`[NEGATIVE_KNOWLEDGE: <query>]`. Writes go only to `.research/`.
+"""
+
+
+def render_stub(skill: str) -> str:
+    tools = ", ".join(f"`{t}`" for t in SKILL_TOOLS.get(skill, []))
+    return STUB_TEMPLATE.format(
+        title=SKILL_TITLES.get(skill, skill.replace("_", " ").title()),
+        skill=skill,
+        tools=tools,
+    )
+
+
+def build():
+    count = 0
+    for target_rel, mode in TARGETS:
+        target_base = PROJECT_ROOT / target_rel
+        target_base.mkdir(parents=True, exist_ok=True)
+        for skill in CANONICAL_SKILLS:
+            src = PROJECT_ROOT / "skills" / skill
+            if not src.exists():
+                print(f"[WARN] canonical skill missing: skills/{skill}", file=sys.stderr)
+                continue
+            if not (src / "SKILL.md").exists():
+                print(f"[WARN] skills/{skill}/SKILL.md missing", file=sys.stderr)
+                continue
+            dst = target_base / skill
+            if dst.exists():
+                shutil.rmtree(dst)
+            dst.mkdir(parents=True, exist_ok=True)
+            (dst / "SKILL.md").write_text(render_stub(skill), encoding="utf-8")
+            count += 1
+    print(f"✅ Built {count} thin skill stubs across {len(TARGETS)} targets.")
+    return 0
+
+
+def check():
+    """Verify stubs match the generated template (not the skill bodies)."""
+    errors = []
+    for target_rel, mode in TARGETS:
+        for skill in CANONICAL_SKILLS:
+            dst = PROJECT_ROOT / target_rel / skill / "SKILL.md"
+            if not dst.exists():
+                errors.append(f"MISSING stub: {target_rel}/{skill}/SKILL.md")
+                continue
+            if dst.read_text(encoding="utf-8") != render_stub(skill):
+                errors.append(f"OUT OF SYNC: {target_rel}/{skill}/SKILL.md")
+            # Stubs must not drag code bodies back in.
+            stray = [
+                p.name
+                for p in (PROJECT_ROOT / target_rel / skill).iterdir()
+                if p.name != "SKILL.md"
+            ]
+            if stray:
+                errors.append(f"STRAY FILES in {target_rel}/{skill}: {sorted(stray)}")
+    # Validate package.json pi/omp blocks resolve
+    pkg = json.loads((PROJECT_ROOT / "package.json").read_text())
+    for key in ("pi", "omp"):
+        block = pkg.get(key, {})
+        for kind in ("skills", "extensions", "prompts"):
+            for p in block.get(kind, []):
+                # glob patterns allowed in prompts
+                if "*" in p:
+                    if not list(PROJECT_ROOT.glob(p.lstrip("./"))):
+                        errors.append(
+                            f"package.json {key}.{kind} glob matches nothing: {p}"
+                        )
+                elif not (PROJECT_ROOT / p.lstrip("./")).exists():
+                    errors.append(f"package.json {key}.{kind} missing: {p}")
+    if errors:
+        print("❌ Adapter check failed:")
+        for e in errors:
+            print(f"   - {e}")
+        return 1
+    print("✅ All adapter stubs in sync with template; package.json pi/omp blocks resolve.")
+    return 0
+
+
+def clean():
+    for target_rel, _ in TARGETS:
+        base = PROJECT_ROOT / target_rel
+        if base.exists():
+            shutil.rmtree(base)
+            print(f"Removed {target_rel}")
+
+
+def main():
+    ap = argparse.ArgumentParser(description="IUMBTEMS adapter builder")
+    ap.add_argument("--check", action="store_true")
+    ap.add_argument("--clean", action="store_true")
+    args = ap.parse_args()
+    if args.clean:
+        return clean()
+    if args.check:
+        return check()
+    return build()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/divergence_experiment.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Stream E / Gate G2: cross-family adversary divergence experiment.
+
+Probe: [HYPOTHESIS: cross-family Alpha/Beta pairs raise mean Divergence
+Score by >= 0.15 vs same-family pairs across 5 fixed objectives]
+
+Runs each fixture objective twice — once with a same-family config, once with
+a cross-family config — and emits a delta artifact under
+.research/experiments/. LIVE MODE SPENDS MONEY: it drives real backends.
+
+Zero-dep: stdlib + the existing SwarmRunner. Token/cost accounting is
+best-effort (chars/4) and reported as an estimate, not a measurement.
+
+Usage:
+  # Dry-run (mock mode, zero cost) — proves the harness, not the hypothesis
+  python3 scripts/divergence_experiment.py --mock
+
+  # Live (requires configured backends and spend approval)
+  python3 scripts/divergence_experiment.py \
+      --beta-backend ollama run qwen3 --model-alpha claude-opus-5
+"""
+
+import argparse
+import json
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from runner.research_swarm import SwarmRunner  # noqa: E402
+
+FIXTURE = PROJECT_ROOT / "runner" / "tests" / "fixtures" / "divergence_objectives.json"
+GATE_BAR = 0.15
+
+
+def load_objectives(path: Path = FIXTURE) -> List[Dict[str, Any]]:
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return data["objectives"]
+
+
+def estimate_tokens(text: str) -> int:
+    """Rough token estimate (chars/4). FLAGGED APPROXIMATION, not a measurement."""
+    return max(1, len(text) // 4)
+
+
+def run_one(
+    objective: str,
+    base_dir: Path,
+    agent_overrides: Optional[Dict[str, Dict[str, Any]]],
+    mock: bool,
+) -> Dict[str, Any]:
+    """Run one swarm under one config and pull divergence out of the audit."""
+    runner = SwarmRunner(
+        base_dir=base_dir,
+        mock_mode=mock,
+        mode="research",
+        agent_overrides=agent_overrides,
+    )
+    started = time.perf_counter()
+    # Suppress the swarm's chatty stdout; the artifact is what matters.
+    import contextlib, io
+
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        runner.run_swarm(objective)
+    elapsed = time.perf_counter() - started
+
+    report_path = base_dir / "final_synthesis.md"
+    divergence = None
+    verified = None
+    audit_paths = sorted((base_dir / "scratchpads").glob("*/audit_report.json"))
+    for ap in audit_paths:
+        try:
+            with open(ap, "r", encoding="utf-8") as f:
+                audit = json.load(f)
+            summary = audit.get("summary", {})
+            if summary.get("divergence_score") is not None:
+                divergence = summary["divergence_score"]
+                verified = summary.get("verified_passed")
+        except (OSError, json.JSONDecodeError):
+            continue
+
+    log = buf.getvalue()
+    return {
+        "divergence_score": divergence,
+        "verified_passed": verified,
+        "wall_clock_s": round(elapsed, 3),
+        "tokens_estimate": estimate_tokens(log),  # FLAGGED APPROXIMATION
+        "report": str(report_path) if report_path.exists() else None,
+    }
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description="Stream E divergence experiment (G2)")
+    parser.add_argument("--mock", action="store_true", help="Mock mode, zero API cost")
+    parser.add_argument("--out-dir", default=None, help="Artifact directory")
+    parser.add_argument("--model-alpha", default=None)
+    parser.add_argument("--model-beta", default=None)
+    parser.add_argument("--beta-backend", nargs="+", default=None)
+    parser.add_argument("--fixture", default=str(FIXTURE))
+    args = parser.parse_args(argv)
+
+    objectives = load_objectives(Path(args.fixture))
+    out_dir = Path(args.out_dir) if args.out_dir else (PROJECT_ROOT / ".research" / "experiments")
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    same_family: Dict[str, Dict[str, Any]] = {}
+    cross_family: Dict[str, Dict[str, Any]] = {}
+    if args.model_alpha:
+        same_family.setdefault("alpha", {})["model"] = args.model_alpha
+        same_family.setdefault("beta", {})["model"] = args.model_alpha
+    if args.model_beta:
+        cross_family.setdefault("beta", {})["model"] = args.model_beta
+    if args.beta_backend:
+        cross_family.setdefault("beta", {})["backend"] = args.beta_backend
+
+    results = []
+    for obj in objectives:
+        oid = obj["id"]
+        print(f"[{oid}] same-family run...", flush=True)
+        same = run_one(
+            obj["objective"],
+            out_dir / "work" / oid / "same",
+            same_family or None,
+            args.mock,
+        )
+        print(f"[{oid}] cross-family run...", flush=True)
+        cross = run_one(
+            obj["objective"],
+            out_dir / "work" / oid / "cross",
+            cross_family or None,
+            args.mock,
+        )
+        d_same = same["divergence_score"]
+        d_cross = cross["divergence_score"]
+        delta = (
+            round(d_cross - d_same, 4)
+            if (d_same is not None and d_cross is not None)
+            else None
+        )
+        results.append({"id": oid, "objective": obj["objective"], "same": same, "cross": cross, "delta_divergence": delta})
+
+    deltas = [r["delta_divergence"] for r in results if r["delta_divergence"] is not None]
+    mean_delta = round(sum(deltas) / len(deltas), 4) if deltas else None
+
+    # A mock run cannot falsify G2: both arms drive the same canned backend,
+    # so a 0.0 delta is a property of the fixture, not of model diversity.
+    if args.mock:
+        gate_status = "UNMEASURED_MOCK"
+    elif mean_delta is None:
+        gate_status = "UNMEASURED"
+    else:
+        gate_status = "PASS" if mean_delta >= GATE_BAR else "FAIL"
+
+    artifact = {
+        "experiment": "divergence-g2",
+        "ran_at": datetime.now(timezone.utc).isoformat(),
+        "mock": args.mock,
+        "fixture": args.fixture,
+        "gate_bar_delta": GATE_BAR,
+        "results": results,
+        "mean_delta_divergence": mean_delta,
+        "gate_g2": gate_status,
+        "token_note": "tokens_estimate is chars/4 — a flagged approximation, not a measurement",
+    }
+
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    out_path = out_dir / f"divergence_{stamp}.json"
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(artifact, f, indent=2)
+
+    print(json.dumps({"mean_delta": mean_delta, "gate_g2": artifact["gate_g2"], "artifact": str(out_path)}, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/brainstorming/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: brainstorming
+description: Lateral creative brainstorming and divergent ideation skill. Use when exploring what-if features, lateral architectures, speculative product directions, or when user invokes /brainstorming. Generates novel feature vectors, paradigm inversions, and falsifiable spike hypotheses instead of bug fixes.
+---
+
+# Creative Brainstorming & Lateral Ideation Engine
+
+Trigger with `/brainstorming <ambiguous-prompt>` (alias `/brainstorm`).
+This skill inverts the default coding-assistant bias (bug fixes, incremental
+refactors) and forces divergent, speculative, lateral thinking.
+
+## 1. Invocation
+
+```bash
+# Interactive / single-pass brainstorm (no LLM tokens required for scaffolding)
+python3 skills/brainstorming/scripts/brainstorm.py --objective "Where do we go from here?" --show-context
+
+# Full dialectic brainstorm swarm (mock = zero token cost)
+python3 runner/research_swarm.py --mode brainstorm --objective "What-if gameplay mechanics for HarborTown" --mock-claude
+
+# Live swarm (invokes Claude Code headless sessions)
+python3 runner/research_swarm.py --mode brainstorm --objective "<objective>"
+
+# Via CLI
+iumbtems brainstorm "Where do we go from here?"
+iumbtems brainstorm "What-if mechanics for HarborTown" --mock-claude
+```
+
+In Pi / OMP: `/brainstorming <prompt>`. In OpenCode: `iumbtems_brainstorm` tool.
+In Gemini / AntiGravity: skill auto-activates on speculative intent.
+In Codex: `$brainstorming <prompt>`.
+
+## 2. Dynamic Context Ingestion (read-only, capped)
+
+Before ideating, the agent MUST ingest (never exceed ~30% of context budget):
+
+1. Project tree: `glob` depth 3 + `README.md`, `AGENTS.md`/`GEMINI.md`/`SYSTEM.md` if present.
+2. Architecture docs: `docs/SYSTEM_ARCHITECTURE.md`, `docs/*`, `prompts/*.md` domain hints.
+3. Recent history: `git log --oneline -20`, `git status --short`.
+4. Open loops: `grep -r "TODO|FIXME|HACK|XXX" --include="*.py" --include="*.ts" --include="*.js" .`
+5. Stack fingerprint: `package.json`, `pyproject.toml`, `Cargo.toml`, `go.mod`, `requirements*.txt`.
+
+Record the result as `domain_model.json`:
+
+```json
+{
+  "domain": "<game mechanics|data pipeline|compiler toolchain|multi-agent runtime|...>",
+  "entities": ["<core entity>"],
+  "constraints": ["<hard constraint>"],
+  "stack": ["<detected dependency>"],
+  "open_loops": ["<TODO>"]
+}
+```
+
+If context budget is < 40% free, fall back to single-pass mode: skip git
+history and full tree, use only README + top-level listing.
+
+## 3. Dialectical Divergence (mandatory)
+
+Run Thesis / Radical Antithesis / Synthesis. Do NOT produce bug-fix lists.
+
+### Thesis — Wild Proponent
+Propose the most ambitious affirmative vision: 10x features, new mechanics,
+new workflows. No feasibility filter.
+
+### Radical Antithesis — Paradigm Inverter
+Invert every Thesis premise:
+- *Inversion*: What if the core objective is obsolete? What replaces it?
+- *Subtraction*: What if we remove the most "essential" component?
+- *Adjacent domains*: What would biology / compilers / markets / games do here?
+- *Cutting-edge OSS*: What new dependency, protocol, or model unlocks a shortcut?
+- *Counter-intuition*: What deliberately "wrong" optimization wins?
+
+### Synthesis — Portfolio Builder
+Output exactly:
+
+1. **Novel Feature Vectors (3-5)**: high-impact "what-if" mechanics or workflows.
+   Each: name, one-line pitch, why now, falsification probe.
+2. **Lateral Architectural Moves (2-3)**: alternative paradigms, OSS swaps,
+   counter-intuitive optimizations. Each: current vs. lateral, trade-off, migration spike.
+3. **Experimental Hypotheses (2-3)**: rapid spikes (< 1 day each). Each MUST carry
+   `[HYPOTHESIS: <measurable falsification criterion>]`.
+
+## 4. Execution Pipeline & Calibration
+
+| Parameter | Brainstorm value | Research/audit value |
+|---|---|---|
+| `temperature` | 1.0 – 1.2 | 0.2 – 0.4 |
+| `top_p` | 0.92 | 0.9 |
+| `max_iterations` | 1 – 2 | 2 – 4 |
+| `divergence` | rewarded (target > 0.6) | audited (threshold 0.75) |
+| `epistemic bar` | `[HYPOTHESIS]` required, `[VERIFIED]` optional | `[VERIFIED]` required |
+
+Topology: isolated subagent by default. With `--swarm`, dispatch via
+`runner/research_swarm.py --mode brainstorm` (Alpha=warm wild proponent,
+Beta=radical inverter, Auditor=divergence-rewarding synthesizer).
+Write output ONLY to `.research/brainstorm_<timestamp>.md` plus
+`scratchpads/brainstorm_<slug>/domain_model.json`.
+
+## 5. Anti-Patterns (hard bans)
+
+- No bug-fix or incremental-refactor lists as "ideas".
+- No sycophantic convergence ("all options are great").
+- No parametric citations presented as `[VERIFIED]` — speculation MUST be
+  tagged `[HYPOTHESIS: <test>]` or `[INFERRED: <parents>]`.
+- No writes outside `.research/`.

package/skills/brainstorming/__init__.py

@@ -0,0 +1 @@
+# AgentSkills compatibility marker