eminiar 0.11.0 → 0.13.0

package/eminiar.config.schema.json

@@ -260,7 +260,8 @@
       "properties": {
         "manifest": {
           "default": ".eminiar/docs.json",
-          "type": "string"
+          "type": "string",
+          "pattern": "^(?![/\\\\])(?![A-Za-z]:)(?!(?:[\\s\\S]*[/\\\\])?\\.\\.[. ]*(?:[/\\\\]|$))[^\\p{Cc}]+$"
         },
         "ttlHours": {
           "default": 168,
@@ -489,6 +490,454 @@
           "type": "boolean"
         }
       }
+    },
+    "adjudicator": {
+      "default": {},
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "default": false,
+          "type": "boolean"
+        },
+        "provider": {
+          "default": "heuristic",
+          "type": "string",
+          "enum": [
+            "heuristic",
+            "typesafe",
+            "openai-compatible",
+            "embedding"
+          ]
+        },
+        "mode": {
+          "default": "advise",
+          "type": "string",
+          "enum": [
+            "advise",
+            "apply"
+          ]
+        },
+        "surfaces": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "prompt": {
+              "default": true,
+              "type": "boolean"
+            },
+            "agent": {
+              "default": true,
+              "type": "boolean"
+            },
+            "plan": {
+              "default": true,
+              "type": "boolean"
+            },
+            "tools": {
+              "default": false,
+              "type": "boolean"
+            }
+          }
+        },
+        "promptMode": {
+          "default": "async",
+          "type": "string",
+          "enum": [
+            "heuristic",
+            "async",
+            "blocking"
+          ]
+        },
+        "typesafe": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "model": {
+              "default": "jev-1.14.0",
+              "type": "string"
+            },
+            "baseUrl": {
+              "default": "https://api.typesafe.ai/v1",
+              "type": "string",
+              "format": "uri"
+            }
+          }
+        },
+        "openai": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "preset": {
+              "default": "groq",
+              "type": "string",
+              "enum": [
+                "groq",
+                "cerebras",
+                "ollama",
+                "lmstudio",
+                "llamacpp",
+                "custom"
+              ]
+            },
+            "baseUrl": {
+              "type": "string",
+              "format": "uri"
+            },
+            "model": {
+              "type": "string"
+            },
+            "json": {
+              "default": "auto",
+              "type": "string",
+              "enum": [
+                "schema",
+                "object",
+                "auto"
+              ]
+            },
+            "price": {
+              "type": "object",
+              "properties": {
+                "inPerM": {
+                  "type": "number",
+                  "minimum": 0
+                },
+                "outPerM": {
+                  "type": "number",
+                  "minimum": 0
+                }
+              },
+              "required": [
+                "inPerM",
+                "outPerM"
+              ]
+            }
+          }
+        },
+        "embedding": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "k": {
+              "default": 5,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            },
+            "minSimilarity": {
+              "default": 0.55,
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            }
+          }
+        },
+        "keyEnv": {
+          "type": "string",
+          "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+        },
+        "remoteConsent": {
+          "default": false,
+          "type": "boolean"
+        },
+        "remoteConsentOrigins": {
+          "maxItems": 64,
+          "type": "array",
+          "items": {
+            "type": "string",
+            "maxLength": 512
+          }
+        },
+        "timeouts": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "promptMs": {
+              "default": 1200,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            },
+            "agentMs": {
+              "default": 800,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            },
+            "planMs": {
+              "default": 3000,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            },
+            "localMs": {
+              "default": 600,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            },
+            "connectMs": {
+              "default": 150,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            }
+          }
+        },
+        "minPromptChars": {
+          "default": 12,
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991
+        },
+        "tiers": {
+          "default": [
+            "haiku",
+            "sonnet",
+            "opus"
+          ],
+          "minItems": 1,
+          "maxItems": 4,
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "haiku",
+              "sonnet",
+              "opus",
+              "fable"
+            ]
+          },
+          "uniqueItems": true
+        },
+        "weights": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "providerMax": {
+              "default": 0.7,
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "embeddingMax": {
+              "default": 0.4,
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "selfReportScale": {
+              "default": 0.6,
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "lowConfidence": {
+              "default": 0.55,
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "tierCenters": {
+              "default": {
+                "haiku": 0.6,
+                "sonnet": 2,
+                "opus": 3.4
+              },
+              "type": "object",
+              "propertyNames": {
+                "type": "string",
+                "maxLength": 32
+              },
+              "additionalProperties": {
+                "type": "number"
+              },
+              "maxProperties": 16
+            },
+            "features": {
+              "default": {},
+              "type": "object",
+              "propertyNames": {
+                "type": "string",
+                "maxLength": 64
+              },
+              "additionalProperties": {
+                "type": "number"
+              },
+              "maxProperties": 64
+            }
+          }
+        },
+        "apply": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "scope": {
+              "default": "swarm",
+              "type": "string",
+              "enum": [
+                "swarm",
+                "all"
+              ]
+            },
+            "minConfidence": {
+              "default": 0.7,
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "floor": {
+              "default": "haiku",
+              "type": "string",
+              "enum": [
+                "haiku",
+                "sonnet",
+                "opus",
+                "fable"
+              ]
+            },
+            "ceiling": {
+              "default": "opus",
+              "type": "string",
+              "enum": [
+                "haiku",
+                "sonnet",
+                "opus",
+                "fable"
+              ]
+            },
+            "respectFrontmatter": {
+              "default": true,
+              "type": "boolean"
+            }
+          }
+        },
+        "advice": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "mainSession": {
+              "default": "user",
+              "type": "string",
+              "enum": [
+                "off",
+                "user",
+                "context"
+              ]
+            },
+            "cooldownPrompts": {
+              "default": 8,
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 9007199254740991
+            }
+          }
+        },
+        "learning": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "default": true,
+              "type": "boolean"
+            },
+            "maxBias": {
+              "default": 0.3,
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "minSamples": {
+              "default": 5,
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 9007199254740991
+            },
+            "halfLife": {
+              "default": 50,
+              "type": "number",
+              "exclusiveMinimum": 0
+            },
+            "costWeight": {
+              "default": 0.05,
+              "type": "number",
+              "minimum": 0
+            }
+          }
+        },
+        "cache": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "ttlHours": {
+              "default": 24,
+              "type": "number",
+              "exclusiveMinimum": 0
+            },
+            "maxEntries": {
+              "default": 2000,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            }
+          }
+        },
+        "breaker": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "failures": {
+              "default": 2,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            },
+            "cooldownSec": {
+              "default": 120,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            }
+          }
+        },
+        "budget": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "dailyUsd": {
+              "default": 0.5,
+              "type": "number",
+              "minimum": 0
+            },
+            "dailyCalls": {
+              "default": 2000,
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 9007199254740991
+            }
+          }
+        },
+        "privacy": {
+          "default": {},
+          "type": "object",
+          "properties": {
+            "maxChars": {
+              "default": 2000,
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            },
+            "storeHead": {
+              "default": true,
+              "type": "boolean"
+            },
+            "captureExchanges": {
+              "default": false,
+              "type": "boolean"
+            }
+          }
+        }
+      }
     }
   },
   "title": "eminiar.config.json",

package/hooks/hooks.json

@@ -16,7 +16,7 @@
     ],
     "PreToolUse": [
       {
-        "matcher": "Bash|Read|Edit|MultiEdit|Write|Grep|Glob|WebFetch|WebSearch|Agent|Task",
+        "matcher": "^(Bash|Read|Edit|MultiEdit|Write|Grep|Glob|WebFetch|WebSearch|Agent|Task|mcp__.*__em_swarm)$",
         "hooks": [
           { "type": "command", "command": "\"${CLAUDE_PLUGIN_ROOT}/bin/em-hook\"", "timeout": 5 }
         ]
@@ -41,6 +41,14 @@
         ]
       }
     ],
+    "SubagentStart": [
+      {
+        "matcher": "^swarm-",
+        "hooks": [
+          { "type": "command", "command": "\"${CLAUDE_PLUGIN_ROOT}/bin/em-hook\"", "timeout": 10 }
+        ]
+      }
+    ],
     "SubagentStop": [
       {
         "hooks": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eminiar",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Local-first context, memory and knowledge-graph plugin for Claude Code and Cursor. Sandboxed execution, FTS5 + vector search, session continuity, and a code graph — nothing leaves your machine.",
   "type": "module",
   "license": "MIT",
@@ -49,7 +49,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsup && tsup --config tsup.web.config.ts && node scripts/copy-grammars.mjs && tsx scripts/gen-schema.ts",
+    "build": "tsup && node scripts/check-bundle.mjs && tsup --config tsup.web.config.ts && node scripts/copy-grammars.mjs && tsx scripts/gen-schema.ts",
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.web.json",
     "test": "vitest run",

package/skills/em-doctor/SKILL.md

@@ -1,9 +1,22 @@
 ---
 name: em-doctor
-description: Diagnose the eminiar installation — node, SQLite FTS5, sqlite-vec, embedding model, sandbox languages, routing mode, context-mode coexistence, project root.
+description: Diagnose the eminiar installation — node, SQLite FTS5, sqlite-vec, embedding model, sandbox languages, routing mode, context-mode coexistence, project root, and the opt-in adjudicator (provider, key, consent, health).
 user-invocable: true
 allowed-tools: mcp__plugin_eminiar_eminiar__em_doctor
 ---
 
 Call `em_doctor` and show the checklist verbatim. For any failed check, suggest the fix in one
 line (usually `npx eminiar install` or `eminiar doctor --fix` from a terminal).
+
+When the adjudicator is on, the `adjudicator*` checks cover: the config is valid; the
+configured provider is the one that runs (or why the heuristic runs instead: no key, no
+consent, an API key rejected, misconfigured); the key is present and `~/.eminiar/adjudicator.key`
+is mode 0600; consent for a remote provider; breaker state and p95 latency against the budget;
+the last 24 h fallback rate; `CLAUDE_CODE_SUBAGENT_MODEL_FORCE` set while mode is apply; in
+apply mode, `adjudicator swarm pins` (information, not a failure) when every role of a swarm
+pins a model without a range, so apply mode cannot change any of its workers; and, for the
+embedding provider, whether the exemplar vectors are cached. Fixes are
+`eminiar adjudicator key set`, `eminiar adjudicator enable --accept-remote`, `chmod 600
+~/.eminiar/adjudicator.key`, `eminiar adjudicator status`, or for swarm pins a `model_range` on
+the roles in `.eminiar/swarm.yaml` followed by `eminiar swarm sync`. `eminiar doctor` (terminal) also
+probes the provider live with a 2 s timeout.

package/skills/em-onboard/SKILL.md

@@ -42,6 +42,38 @@ Then write, via `em_remember {kind: "onboarding", name: …, content: …}`:
   are, which local specs exist, and the rule: `em_docs {action: "lookup", query}` before
   WebFetch/WebSearch for anything the project depends on.
 
+Then ask about the adjudicator (optional; it is off by default and is never turned on
+without a yes). Skip this step if the user asked for a non-interactive or default onboarding,
+or if `eminiar adjudicator status --json` (run with `em_execute`, language shell; use
+`npx eminiar` if `eminiar` is not on PATH) shows it is already on.
+
+1. Explain in two sentences: the adjudicator scores how complex each prompt, subagent task
+   and swarm task is and suggests the eminiar tool, the Claude model size (haiku / sonnet /
+   opus) and the swarm agent role for it, to save tokens. Then ask exactly:
+   **"Use the adjudicator for tool, model and agent selection? (default: no)"**
+   Anything but a clear yes means no: say `eminiar adjudicator enable` turns it on later, and stop.
+2. On yes, ask which provider, and say for each whether text leaves the machine:
+   - **heuristic** (default): built-in rules; offline, nothing leaves this machine.
+   - **embedding**: nearest examples with the local embedding model; offline.
+   - **Jev** (TypeSafe, api.typesafe.ai): hosted; sends prompt text off this machine; needs an API key.
+   - **OpenAI-compatible**: a local server (Ollama on 11434, LM Studio on 1234, llama.cpp on
+     8080; nothing leaves the machine) or a hosted one (Groq, Cerebras; sends prompt text off
+     this machine; needs an API key). `eminiar adjudicator provider --detect` finds local servers.
+3. For a choice that sends text off the machine, quote this and get an explicit yes before
+   continuing: "The text of your prompts and subagent tasks (redacted, at most 2000 chars) is
+   sent to <host> to score them." Without that yes, fall back to the heuristic.
+4. Turn it on with `em_execute` (shell), adding `--accept-remote` only after that explicit yes:
+   `eminiar adjudicator enable --provider <heuristic|embedding|typesafe|ollama|lmstudio|llamacpp|groq|cerebras> [--accept-remote]`
+5. For Jev or a hosted preset the key goes into the local key file `~/.eminiar/adjudicator.key`
+   (mode 0600), never into the chat, a config file or a command line. Ask the user to run, in
+   their own terminal: `eminiar adjudicator key set typesafe` (or `groq` / `cerebras`), which
+   reads the key at a hidden prompt. If the key is already in an environment variable,
+   `eminiar adjudicator key set --from-env NAME` stores only the variable's name. If the user
+   pastes a key into the chat anyway, do not repeat it or put it in a command; tell them to
+   rotate it and use the hidden prompt.
+6. Finish with `eminiar adjudicator status` and tell the user to run `/mcp reconnect` so the
+   `em_adjudicate` tool loads (hooks pick the change up on the next prompt).
+
 Finish with one line listing the five names; mention that the files live under
 `.eminiar/memories/onboarding/` and the manifest at `.eminiar/docs.json`, and that both
-should be committed.
+should be committed. Add whether the adjudicator was turned on, and with which provider.

package/skills/em-swarm/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: em-swarm
+description: Coordinate an eminiar agent swarm from the main session — start a run of a swarm defined in .eminiar/swarm.yaml, plan small tasks, fan out worker subagents (swarm-<swarm>-<role>) in parallel, watch the task board, review the results and finish the run with a memory. Use when the user asks to run a swarm, use the X swarm, fan out workers, or parallelise a review across roles.
+user-invocable: true
+argument-hint: <swarm> <goal>
+allowed-tools: mcp__plugin_eminiar_eminiar__em_swarm, mcp__plugin_eminiar_eminiar__em_recall, mcp__plugin_eminiar_eminiar__em_history, mcp__plugin_eminiar_eminiar__em_graph_impact, mcp__plugin_eminiar_eminiar__em_architecture, mcp__plugin_eminiar_eminiar__em_symbols, mcp__plugin_eminiar_eminiar__em_remember, Agent
+---
+
+Arguments: $ARGUMENTS (first word: the swarm; the rest: the goal)
+
+You are the **coordinator**. Subagents cannot spawn subagents, so only you plan, spawn and
+review; workers are leaves that claim tasks and report back through `em_swarm`.
+
+**Use a swarm when** the goal splits into 3 or more pieces of work that can run independently
+(separate files or modules), or when you want several reviewers to look at the same change
+from different angles at once.
+
+**Skip it when** the change is a single-file edit, a quick fix, or tightly coupled sequential
+work where each step needs the previous step's exact output. Do the work directly instead.
+
+## 0. Check the swarm exists
+
+Call `em_swarm {action:"list"}`. If it says swarms are opt-in or disabled, stop and tell the user
+how to opt in: `eminiar swarm init` (starter `.eminiar/swarm.yaml` plus generated agents), the
+"Create starter swarm.yaml" button on the dashboard's Swarms tab (`eminiar ui`), or writing the
+file by hand (https://github.com/rydn/eminiar/blob/main/docs/swarms.md). Do not improvise a swarm with ad-hoc subagents. If the file has
+validation errors, show them and stop. If it says the call was not stamped by eminiar's hook,
+stop and tell the user to run `eminiar upgrade` (or `eminiar install`) and check `/hooks`:
+without the stamp every change is refused. If no swarm was named, pick the one whose description
+fits the goal and say which.
+
+## 1. Start the run
+
+`em_swarm {action:"start", swarm, goal}` returns your brief: the topology's rules, the roles with
+their `subagent_type`, model and `count`, the capacity (`max_agents`), the swarm's own
+instructions, and what eminiar knows (memories, bug-prone files, hot files, project brief).
+Read it before planning. Check `em_recall` / `em_architecture` / `em_graph_impact` for anything
+the brief leaves open.
+
+If it warns that the swarm already has an active run in this session, either finish the old run
+(`em_swarm {action:"finish", run, status:"cancelled"}`) or pass `run` on every later call: while
+several runs are active, calls without `run` are refused with the list of runs.
+
+## 2. Plan small tasks
+
+`em_swarm {action:"plan", tasks:[{key, title, detail, role, deps, files}]}`
+
+- One task = what one worker can finish in one go. Name the files it touches in `files`.
+- Only those six keys; put anything else in `detail` (other keys are refused).
+- `role` must be a role of the swarm. `deps` take task ids or the `key` of an earlier task in the
+  same call. Avoid two parallel tasks editing the same file.
+- Hierarchical: you assign every task to a role. Mesh: seed tasks; workers claim any.
+  Pipeline: a stage opens only when every task of the earlier stages is done. In every topology
+  workers may plan follow-up tasks (a reviewer adds fixes for the coder).
+
+## 3. Spawn workers
+
+For each claimable task (the plan reply lists them), call the **Agent** tool with
+`subagent_type: "swarm-<swarm>-<role>"` and a prompt that names the task as **"task #N"** plus
+anything the worker needs beyond the task text. The worker claims that task itself as its first
+step; eminiar briefs it with the project knowledge when it starts and with the task when it
+claims.
+
+- Use `run_in_background: true` to run independent tasks in parallel.
+- `max_agents` caps the swarm's running workers across all its runs, and `count` caps each role.
+  eminiar denies spawns over capacity; if that happens, wait for a worker to finish or release a
+  stuck one (step 4).
+- Spawn a task only once its deps are done.
+
+## 4. Watch
+
+`em_swarm {action:"status"}` starts with the next step, then shows tasks by status, workers,
+blackboard keys and recent events. For long runs, run `eminiar swarm watch` under the
+**Monitor** tool. Its first line is `swarm.snapshot` (or `swarm.finished` if the run is already
+closed); after that it prints one JSON line per change: `swarm.changed` while work is in flight,
+`swarm.idle` when no worker is running and no task is active except ones held by quiet workers
+(`stale_held`), which means it is your turn, and `swarm.finished` at the end. Workers' tool calls
+never produce a line. Read shared findings with `em_swarm {action:"read"}`. Spawn the next
+workers as deps complete.
+
+A task line flagged **holder quiet Nm** belongs to a worker silent for 15 minutes or more,
+usually one that crashed. Free it with `em_swarm {action:"release", agent}` (with no `agent`,
+every quiet worker is released); the task goes back to pending, so spawn a new worker for it.
+
+## 5. Review
+
+- Read every result. A task flagged **auto-closed** was closed from the worker's last message
+  because it never reported: check that the work is really done.
+- Reopen unfinished work with `em_swarm {action:"update", task, status:"pending"}` or plan
+  follow-up tasks; `blocked` tasks need an answer or a re-plan.
+- If the swarm has a reviewer role, run it **last**, on the full diff, as an adversarial
+  review. Turn each confirmed finding into a task and repeat until none are left.
+- Run the tests yourself before you call the goal met.
+
+## 6. Finish
+
+`em_swarm {action:"finish", status:"done"|"failed"|"cancelled", summary, remember:true}` closes
+the run and its running workers, and writes the outcome as a memory (`swarm/run-<date>-<slug>`). Record durable decisions
+and constraints the run produced with `em_remember`. Then report to the user: what changed,
+which files, what was verified, and anything left open.