@heretek-ai/epistemic-swarm 0.7.23 → 0.7.24

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "epistemic-swarm",
-  "version": "0.7.23",
+  "version": "0.7.24",
   "description": "High-Integrity Dialectic Research Agent Harness for Claude Code enforcing empirical evidence over parametric hallucination.",
   "author": {
     "name": "Heretek AI",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heretek-ai/epistemic-swarm",
-  "version": "0.7.23",
+  "version": "0.7.24",
   "description": "IUMBTEMS (Epistemic Swarm) \u2014 High-Integrity Dialectic Research Agent Harness for Claude Code, OpenCode V2, Pi (pi.dev), OMP (oh-my-pi), Gemini CLI, Codex CLI, and AntiGravity",
   "main": "bin/cli.js",
   "bin": {

package/plugins/antigravity/README.md

@@ -1,6 +1,6 @@
 # IUMBTEMS for AntiGravity
 
-First-class native AntiGravity plugin (`agy`) delivering dialectic research, architecture auditing, competitor teardowns, lateral brainstorming, and Socratic planning.
+First-class native AntiGravity plugin (`agy`) delivering dialectic research, architecture auditing, competitor teardowns, lateral brainstorming, Socratic planning, and automated quality gates.
 
 ## Installation
 
@@ -22,13 +22,16 @@ agy plugin validate /path/to/IUMBTEMS/plugins/antigravity
 
 ```text
 plugins/antigravity/
-├── plugin.json       # Manifest conforming to https://antigravity.google/schemas/v1/plugin.json
-├── hooks.json        # PreToolUse, PreInvocation, PostToolUse, and Stop lifecycle hooks
-├── mcp_config.json   # First-party stdio MCP server (17 iumbtems_* tools) + search fallbacks
-├── commands/         # Interactive slash commands (/audit, /swarm, /grill, /factory, etc.)
-├── agents/           # Specialized subagents (alpha-thesis, beta-antithesis, auditor, etc.)
-├── rules/            # Workspace rules (AGENTS.md and epistemic-integrity.md)
-└── skills/           # Generated skill stubs for progressive disclosure
+├── plugin.json          # Manifest conforming to https://antigravity.google/schemas/v1/plugin.json
+├── hooks.json           # PreToolUse, PreInvocation, PostToolUse, and Stop lifecycle hooks
+├── antigravity_hooks.py # Python lifecycle dispatcher with zero-overhead fast-paths
+├── hook_bus_bridge.js   # 6-event Hook Bus & Quality Gates bridge (Analysis, Dep Health, Weight)
+├── mcp_config.json      # First-party stdio MCP server (17 iumbtems_* tools) + search fallbacks
+├── mcp_launcher.py      # MCP runtime launcher and environment resolver
+├── commands/            # Interactive slash commands (/audit, /swarm, /grill, /factory, etc.)
+├── agents/              # Specialized subagents (alpha-thesis, beta-antithesis, auditor, etc.)
+├── rules/               # Workspace rules (AGENTS.md and epistemic-integrity.md)
+└── skills/              # Generated skill stubs for progressive disclosure
 ```
 
 ## Slash Commands
@@ -40,6 +43,7 @@ In the `agy` TUI prompt box, type `/` to access commands:
 - `/factory <action>`: Phased engineering factory with dual QA gating.
 - `/scout <feature>`: Open-source package discovery and copyleft license auditing.
 - `/brainstorming <prompt>`: Divergent lateral ideation and falsifiable spikes.
+- `/brainstorm <prompt>`: Alias for `/brainstorming`.
 - `/domainexpansion <query>`: Domain pack discovery and frontier synthesis.
 - `/swarm-config`: Interactive inspection and configuration of research parameters.
 
@@ -57,7 +61,12 @@ Manage and delegate to specialized subagents using the `/agents` panel or `Alt+J
 - `qa-a`: Functional QA (verifies acceptance criteria).
 - `qa-b`: Adversarial QA (hunts edge cases and loopholes).
 
-## Lifecycle Interception & MCP Tooling
+## Lifecycle Interception & Quality Gates
 - **Search Interception**: Web searches and fetches are intercepted to ensure citations are content-addressed and stored in `.research/sources/<sha256>.md`.
-- **Termination Gating**: The agent loop is gated from stopping prematurely if unresolved claims or failing gates remain in `.research/`.
+- **PreCommit Gating**: File writes to `.research/config.json` are gated by schema validation and `expected_hash` optimistic concurrency.
+- **Analysis Bridge**: Advisory Biome static analysis checks modified JS/TS files in fast tier.
+- **Dependency Health**: Advisory OSV.dev vulnerability auditing scans npm, pip, Dockerfile, and GitHub Actions dependencies.
+- **Weight Signals**: Advisory esbuild bundling tracks package weight and coverage deltas against checked-in baselines.
+- **Compaction Preservation**: Preserves `.research` state (mode, engine, depth, degraded claims, requeued scopes) across context compaction turns.
+- **Termination Gating**: The agent loop is gated from stopping prematurely if unresolved claims (`STALE`/`SUSPECT`) or failing gates remain in `.research/`.
 - **MCP Tools**: All 17 canonical `iumbtems_*` tools are exposed via `runner/mcp_server.py`.

package/plugins/antigravity/antigravity_hooks.py

@@ -3,7 +3,13 @@
 Antigravity Lifecycle Hook Interceptor & Epistemic Gate Bridge.
 
 Binds Antigravity's lifecycle events (PreToolUse, PreInvocation, PostToolUse, Stop)
-to IUMBTEMS's epistemic evidence verification pipeline.
+to IUMBTEMS's epistemic evidence verification pipeline and the 6-event Hook Bus:
+1. Analysis Bridge (Biome CLI static analysis for JS/TS)
+2. Dependency Health Gate (OSV.dev vulnerability & freshness scanner)
+3. Weight Signals (esbuild bundle weight & coverage deltas vs baseline)
+4. Pre-commit gating on .research/config.json with optimistic concurrency (expected_hash)
+5. Session context & compaction preservation (buildCompactionContext)
+6. Living dossier claim degradation stop-gating
 
 Contract Invariants:
 - Input is received as JSON on stdin (camelCase per Antigravity hook protojson).
@@ -14,15 +20,19 @@ Contract Invariants:
 
 import json
 import os
+import shutil
+import subprocess
 import sys
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional
 
 
 def _get_workspace_dir(payload: Dict[str, Any]) -> Path:
     workspaces = payload.get("workspacePaths", [])
-    if workspaces:
+    if workspaces and workspaces[0]:
         return Path(workspaces[0]).resolve()
+    if payload.get("workspaceRoot"):
+        return Path(payload["workspaceRoot"]).resolve()
     if "IUMBTEMS_WORKSPACE" in os.environ:
         return Path(os.environ["IUMBTEMS_WORKSPACE"]).resolve()
     if "IUMBTEMS_ROOT" in os.environ:
@@ -34,6 +44,48 @@ def _get_workspace_dir(payload: Dict[str, Any]) -> Path:
     return curr
 
 
+def _find_hook_bus_bridge(workspace_dir: Path) -> Optional[Path]:
+    script_dir = Path(__file__).resolve().parent
+    candidates = [
+        script_dir / "hook_bus_bridge.js",
+        script_dir.parent / "antigravity" / "hook_bus_bridge.js",
+        workspace_dir / "plugins" / "antigravity" / "hook_bus_bridge.js",
+    ]
+    for c in candidates:
+        if c.is_file():
+            return c
+    return None
+
+
+def _run_node_bridge(action: str, payload: Dict[str, Any], timeout: int = 5) -> Dict[str, Any]:
+    try:
+        node_bin = shutil.which("node")
+        if not node_bin:
+            return {}
+        workspace_dir = _get_workspace_dir(payload)
+        bridge_script = _find_hook_bus_bridge(workspace_dir)
+        if not bridge_script:
+            return {}
+
+        proc = subprocess.run(
+            [node_bin, str(bridge_script), action],
+            input=json.dumps(payload),
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=str(workspace_dir),
+        )
+        if proc.returncode == 0 and proc.stdout.strip():
+            # Parse the last line starting with { to avoid node warnings
+            for line in reversed(proc.stdout.strip().splitlines()):
+                line = line.strip()
+                if line.startswith("{") and line.endswith("}"):
+                    return json.loads(line)
+    except Exception:
+        pass
+    return {}
+
+
 def _read_stdin_payload() -> Dict[str, Any]:
     try:
         content = sys.stdin.read()
@@ -45,10 +97,12 @@ def _read_stdin_payload() -> Dict[str, Any]:
 
 
 def handle_pre_tool(payload: Dict[str, Any]) -> Dict[str, Any]:
-    """Intercept ungrounded search/fetch and redirect to epistemic cache tools."""
+    """Intercept ungrounded search/fetch, pre-commit config edits, and pre-tool hooks."""
     tool_call = payload.get("toolCall", {})
     name = str(tool_call.get("name", "")).lower()
+    args = tool_call.get("args", {})
 
+    # 1. Epistemic Search & Fetch Quarantine (<1ms fast-path)
     if "search_web" in name or "websearch" in name:
         return {
             "decision": "deny",
@@ -69,27 +123,58 @@ def handle_pre_tool(payload: Dict[str, Any]) -> Dict[str, Any]:
             ),
         }
 
+    # 2. Mutating tool calls: run pre-commit config check & hook bus
+    target_file = str(args.get("TargetFile") or args.get("file") or args.get("path") or "")
+    is_mutating = name in ("write_to_file", "replace_file_content", "run_command")
+
+    if is_mutating or (".research" in target_file):
+        bridge_res = _run_node_bridge("pre_tool", payload, timeout=3)
+        if bridge_res.get("decision") == "deny" or bridge_res.get("allowed") is False:
+            return {
+                "decision": "deny",
+                "reason": bridge_res.get("reason", "Blocked by Pre-Commit quality gate"),
+            }
+
     return {"decision": "allow"}
 
 
 def handle_pre_invocation(payload: Dict[str, Any]) -> Dict[str, Any]:
-    """Inject ephemeral evidence tagging constraints before model reasoning."""
-    return {
-        "injectSteps": [
-            {
-                "ephemeralMessage": (
-                    "[EPISTEMIC INTEGRITY] Every factual claim must carry "
-                    "[VERIFIED: <sha256>] (verbatim quote in .research/sources/<hash>.md), "
-                    "[INFERRED: <parents>], [HYPOTHESIS: <test>], or [NEGATIVE_KNOWLEDGE: <query>]. "
-                    "Unverified parametric recall is strictly quarantined."
-                )
-            }
-        ]
-    }
+    """Inject ephemeral evidence tagging constraints, compaction context, and quality gate notices."""
+    inject_steps: List[Dict[str, Any]] = [
+        {
+            "ephemeralMessage": (
+                "[EPISTEMIC INTEGRITY] Every factual claim must carry "
+                "[VERIFIED: <sha256>] (verbatim quote in .research/sources/<hash>.md), "
+                "[INFERRED: <parents>], [HYPOTHESIS: <test>], or [NEGATIVE_KNOWLEDGE: <query>]. "
+                "Unverified parametric recall is strictly quarantined."
+            )
+        }
+    ]
+
+    # Query Node bridge for compaction context and pending quality gate annotations
+    bridge_res = _run_node_bridge("pre_invocation", payload, timeout=3)
+    compaction = bridge_res.get("compactionContext")
+    if compaction and isinstance(compaction, str):
+        inject_steps.append({"ephemeralMessage": compaction})
+
+    annotations = bridge_res.get("annotations") or []
+    if annotations and isinstance(annotations, list):
+        notices = []
+        for a in annotations:
+            if isinstance(a, dict) and a.get("reason"):
+                notices.append(f"- {a.get('handler', 'QualityGate')}: {a['reason']}")
+            elif isinstance(a, str):
+                notices.append(f"- {a}")
+        if notices:
+            inject_steps.append({
+                "ephemeralMessage": "[QUALITY GATES ADVISORY]\n" + "\n".join(notices)
+            })
+
+    return {"injectSteps": inject_steps}
 
 
 def handle_post_tool(payload: Dict[str, Any]) -> Dict[str, Any]:
-    """Log tool completions and record negative knowledge on failures."""
+    """Log tool completions, record negative knowledge, and dispatch to quality gates."""
     try:
         workspace_dir = _get_workspace_dir(payload)
         research_dir = workspace_dir / ".research"
@@ -104,19 +189,24 @@ def handle_post_tool(payload: Dict[str, Any]) -> Dict[str, Any]:
             }
             with log_file.open("a", encoding="utf-8") as f:
                 f.write(json.dumps(entry) + "\n")
+
+        tool_call = payload.get("toolCall", {})
+        name = str(tool_call.get("name", "")).lower()
+        if name in ("write_to_file", "replace_file_content", "run_command"):
+            _run_node_bridge("post_tool", payload, timeout=4)
     except Exception:
         pass
     return {}
 
 
 def handle_stop(payload: Dict[str, Any]) -> Dict[str, Any]:
-    """Prevent agent from terminating if an active swarm run has unverified claims."""
+    """Prevent agent from terminating if an active swarm run has unverified claims or unsettled gates."""
     try:
         workspace_dir = _get_workspace_dir(payload)
         research_dir = workspace_dir / ".research"
 
         # If a STOP signal file was placed by user or factory, respect it immediately
-        factory_stop = (workspace_dir / ".factory" / "STOP")
+        factory_stop = workspace_dir / ".factory" / "STOP"
         if factory_stop.exists():
             return {"decision": "allow"}
 
@@ -139,6 +229,14 @@ def handle_stop(payload: Dict[str, Any]) -> Dict[str, Any]:
                     }
             except Exception:
                 pass
+
+        # Query Node hook bus bridge for stop event denial
+        bridge_res = _run_node_bridge("stop", payload, timeout=3)
+        if bridge_res.get("decision") == "continue" or bridge_res.get("allowed") is False:
+            return {
+                "decision": "continue",
+                "reason": bridge_res.get("reason", "Blocked by Hook Bus stop policy"),
+            }
     except Exception:
         pass
     return {"decision": "allow"}

package/plugins/antigravity/commands/audit.md

@@ -1,10 +1,11 @@
 ---
-description: Dialectic codebase architecture and security audit with line-level proof
+description: Run dialectic codebase architectural and security audit with line-level proof
 ---
 
-Run the IUMBTEMS dialectic codebase audit on `$1`:
+Run an IUMBTEMS dialectic codebase audit (structural architect vs adversarial red-teamer).
 
-`python3 runner/research_swarm.py --mode audit --objective "$1"`
+Target: $ARGUMENTS (path, component, or empty for full-repository architecture and vulnerability audit)
+If $ARGUMENTS names a path that does not exist, ask the user to clarify the target first; never audit a placeholder path.
 
-Report: `.research/code_audit_report.md` with `file:///path#Lstart-Lend` pointers
-and verbatim snippets. Every vulnerability needs a concrete patch blueprint.
+1. Execute `iumbtems_code_audit` with `{"target": "<target>"}` (or `python3 runner/research_swarm.py --mode audit --objective "$ARGUMENTS"`).
+2. Summarize `.research/code_audit_report.md` with line-level proof pointers (`file:///path#Lstart-Lend`) and concrete remediation blueprints.

package/plugins/antigravity/commands/brainstorm.md

@@ -0,0 +1,9 @@
+---
+description: Alias for /brainstorming
+---
+
+Alias for /brainstorming: run lateral brainstorming (divergent what-if ideation, never bug-fix lists).
+
+Prompt: $ARGUMENTS (defaults to "Where do we go from here?" when empty)
+
+Execute `iumbtems_brainstorm` with {"objective": "$ARGUMENTS"} and report feature vectors, paradigm inversions, and falsifiable spikes.

package/plugins/antigravity/commands/brainstorming.md

@@ -1,12 +1,10 @@
 ---
-description: Lateral brainstorming — novel feature vectors and speculative spikes
+description: Lateral brainstorming: novel feature vectors, paradigm inversions, falsifiable spikes
 ---
 
-Run IUMBTEMS lateral brainstorming on `$1` (see `skills/brainstorming/SKILL.md`
-and `prompts/agent_brainstormer.md`):
+Run lateral brainstorming (divergent what-if ideation, never bug-fix lists).
 
-1. Ingest workspace context read-only (`python3 skills/brainstorming/scripts/brainstorm.py --objective "$1" --show-context`).
-2. Thesis / Radical Antithesis / Synthesis — never bug-fix lists.
-3. Output Novel Feature Vectors (3-5), Lateral Architectural Moves (2-3),
-   Experimental Hypotheses (2-3 with `[HYPOTHESIS:<falsification test>]`).
-4. Write `.research/brainstorm_report.md` (or run `python3 runner/research_swarm.py --mode brainstorm --objective "$1"`).
+Prompt: $ARGUMENTS (defaults to "Where do we go from here?" when empty)
+
+1. Execute `iumbtems_brainstorm` with `{"objective": "<prompt>"}` (or `python3 runner/research_swarm.py --mode brainstorm --objective "$ARGUMENTS"`).
+2. Report novel feature vectors, paradigm inversions, and falsifiable spikes (`[HYPOTHESIS:<test>]`) from `.research/brainstorm_report.md`.

package/plugins/antigravity/commands/darkharvest.md

@@ -2,10 +2,11 @@
 description: Product competitor teardown with per-feature harvest verdicts
 ---
 
-Run a product competitor teardown for `$1`:
+Run a product competitor teardown (seed inspirations plus prompt, expand to adjacents).
 
-`python3 runner/research_swarm.py --mode darkharvest --objective "$1"`
+Objective: $ARGUMENTS (product arena; seeds may be embedded as URLs)
+If $ARGUMENTS is empty, ask the user for the product arena and seed URLs first; never call with placeholder arguments.
 
-Seeds may be embedded as repo URLs; cap live runs at `--max-repos 6`.
-Permissive-only vendor; GPL/AGPL clean-room-rebuild only; workflows clonable, assets never.
-Report: `.research/darkharvest_report.md` (matrix + white-space gaps + SPDX backlog).
+1. Execute `iumbtems_darkharvest` with `{"objective": "<objective>", "seeds": ["<url>", "..."]}` (or `python3 runner/research_swarm.py --mode darkharvest --objective "$ARGUMENTS"`).
+2. Report the competitor x capability matrix, white-space gaps both ways, and the SPDX-attributed harvest backlog in `.research/darkharvest_report.md`.
+3. Legal rule: permissive-only vendor; GPL/AGPL clean-room-rebuild only; workflows clonable, assets never.

package/plugins/antigravity/commands/domainexpansion.md

@@ -1,9 +1,12 @@
 ---
-description: Autonomous agent-guided self-improvement loop (count-flagged)
+description: Autonomous agent-guided self-improvement loop over the codebase (count-flagged)
 ---
 
-Run the IUMBTEMS domain-expansion loop for `$1` loops (max 10):
+Run the IUMBTEMS domain-expansion loop as the manager agent.
 
-Bypasses per-loop gates; stops on count OR `.factory/STOP` file OR user kill.
-Each loop: agents propose direction, quick swarm check, implement, dual-QA verify.
-Enforce via the `iumbtems_factory` tool (expansion command with loops/max_loops).
+Loops: $ARGUMENTS (integer count, max 10)
+If $ARGUMENTS is not a positive integer, ask the user for the loop count first.
+
+1. Bypass per-loop gates; stop on count OR .factory/STOP file OR user kill, whichever first (enforce via the `iumbtems_factory` tool, command: expansion, with loops/max_loops).
+2. Each loop: agents propose direction, quick `iumbtems_brainstorm`/`iumbtems_darkharvest` check, implement via programmer spawn, dual-QA verify.
+3. All expansion proposals carry the strict VERIFIED evidence bar; log every loop to `.factory/state.json`.

package/plugins/antigravity/commands/factory.md

@@ -1,9 +1,14 @@
 ---
-description: Coding-factory Manager loop with grill-gated phased builds
+description: Coding-factory Manager loop: grill-gated phased build with programmer spawns and dual QA
 ---
 
-Run the IUMBTEMS coding-factory Manager loop for `$1`:
+Run the IUMBTEMS coding-factory Manager loop as the manager agent.
 
-1. Grill until `.factory/frontier.json` is settled (max 5 swarm cycles per gate); explicit user approve advances each gate.
-2. Per gate: `python3 runner/research_swarm.py --mode brainstorm` plus `--mode darkharvest` (mock-first), then synthesize `.roadmap/<phase>/` GOAL.md + dossier.json.
-3. Programmer subagent per phase; qa-a plus qa-b per phase; retries tracked via the `iumbtems_factory` tool (phase-add / qa-record; 3 failures escalate). Never invoke factory helper scripts by relative path.
+Arena: $ARGUMENTS
+If $ARGUMENTS is empty, ask the user what to build first; never proceed on placeholder input.
+
+1. Grill the user until `.factory/frontier.json` is settled (max 5 brainstorm+darkharvest swarm cycles per gate); explicit user approve advances each gate.
+2. Per gate run `iumbtems_brainstorm` and `iumbtems_darkharvest` (mock_mode only for dry runs), then synthesize `.roadmap/<phase>/` GOAL.md + dossier.json (goal/evidence/acceptance/brief/verdict/hashes; every claim needs a VERIFIED hash).
+3. Spawn the programmer subagent per phase with the phase dossier (cite phase hashes); run qa-a and qa-b (diverged prompts) per phase; track retries with the `iumbtems_factory` tool (command: phase-add / qa-record; 3 failures escalate to manager). Never invoke factory helper scripts by relative path.
+4. Manager tiebreaks QA disagreements; explicit user sign-off closes each phase.
+Swarm agents use the host-native backend automatically. Do not debug backend selection, config pins, or binary availability as part of a gate — if a swarm call fails, report the error and continue.

package/plugins/antigravity/commands/grill.md

@@ -1,9 +1,10 @@
 ---
-description: Socratic grilling and decision frontier exploration
+description: Launch Socratic grilling and decision tree frontier exploration
 ---
 
-Launch IUMBTEMS Socratic grilling for `$1`.
+Launch Socratic grilling on the decision frontier.
 
-Follow `skills/grilling/SKILL.md` (rounds, frontier, assumption inversion,
-factual vs decisional separation). Persist with
-`python3 skills/grilling/socratic_tree.py --export`.
+Objective: $ARGUMENTS (may be empty to inspect the current frontier)
+
+Call `iumbtems_socratic_frontier` with `{"objective": "<objective>", "file": ".research/frontier.json"}` (or `python3 skills/grilling/socratic_tree.py --export`); omit "objective" to inspect.
+Challenge premises, invert assumptions, and report open frontier nodes.

package/plugins/antigravity/commands/scout.md

@@ -1,10 +1,11 @@
 ---
-description: Scout open-source libraries and build clean-room blueprints
+description: Scout open-source libraries, audit copyleft licenses, generate clean-room blueprints
 ---
 
-Scout open-source solutions for `$1`:
+Scout open-source solutions for the requested capability.
 
-`python3 runner/research_swarm.py --mode scout --objective "$1"`
+Feature: $ARGUMENTS
+If $ARGUMENTS is empty, ask the user for the feature or algorithm first; never call with placeholder arguments.
 
-Flag GPL/AGPL contamination, solo-maintainer risk, dependency weight, CVEs.
-Report: `.research/oss_scout_report.md` plus a clean-room re-implementation blueprint.
+1. Execute `iumbtems_oss_scout` with `{"feature": "<feature>"}` (or `python3 runner/research_swarm.py --mode scout --objective "$ARGUMENTS"`).
+2. Report mature candidates, GPL/AGPL copyleft risks, and the clean-room blueprint in `.research/oss_scout_report.md`.

package/plugins/antigravity/commands/swarm-config.md

@@ -1,10 +1,9 @@
 ---
-description: Inspect or tune Epistemic Swarm parameters (engine, depth, mode)
+description: Inspect or update Epistemic Swarm parameters (engine, depth, mode)
 ---
 
-Inspect or tune IUMBTEMS swarm parameters: `$1`.
+Inspect or update the Epistemic Swarm configuration.
 
-`python3 skills/swarm_config/configure.py $1`
+Arguments: $ARGUMENTS (may be empty to inspect current settings)
 
-Engines: `duckduckgo` (zero-key default), `brave`, `firecrawl`, `searxng`.
-Modes: `research`, `audit`, `scout`, `hybrid`, `brainstorm`. Depth: 1-4.
+Call `iumbtems_config`; map `--engine`/`--depth`/`--mode`/`--show` style flags to search_engine/max_iterations/mode, or pass through no arguments to inspect (or run `python3 skills/swarm_config/configure.py $ARGUMENTS`).

package/plugins/antigravity/commands/swarm.md

@@ -2,8 +2,11 @@
 description: Run IUMBTEMS dialectic research swarm on an objective
 ---
 
-Run the IUMBTEMS dialectic research swarm on `$1`.
+Run an IUMBTEMS dialectic research swarm.
 
-1. If the objective is ambiguous, follow `skills/grilling/SKILL.md` first.
-2. Execute `python3 runner/research_swarm.py --objective "$1" $@[2:]`.
+Objective: $ARGUMENTS
+If $ARGUMENTS is empty, ask the user for the research objective first; never call with placeholder, empty, or literal "<objective>" arguments.
+
+1. If the objective is ambiguous, frame it first via `iumbtems_socratic_frontier`.
+2. Execute `iumbtems_swarm_research` with `{"objective": "<objective>"}` (or `python3 runner/research_swarm.py --objective "$ARGUMENTS"`).
 3. Summarize `.research/final_synthesis.md`, preserving `[VERIFIED:<hash>]` pointers.