@eventmodelers/cli 1.0.79 → 1.0.80

package/README.md

@@ -335,7 +335,20 @@ SGLang all serve. Everything above the transport is identical, which is why anyt
 OpenAI-compatible works by pointing `LOCAL_AI_URL` at it. The `LOCAL_AI_*` vars are the same
 ones a build kit's local runner reads (`LOCAL_AI_TARGET`, `LOCAL_AI_URL`, `LOCAL_AI_API`,
 `LOCAL_AI_MODEL`, `LOCAL_AI_API_KEY`, `LOCAL_AI_NUM_CTX`), or set them once as `localAi` in
-`.eventmodelers/config.json`.
+`.eventmodelers/config.json` — env wins over the file, the file over the preset:
+
+```json
+{
+  "boardId": "...",
+  "token": "...",
+  "localAi": {
+    "target": "ollama",
+    "url": "http://localhost:11434",
+    "model": "qwen3.5:9b",
+    "numCtx": 49152
+  }
+}
+```
 
 **What you get and what you don't.** The loop around the turn is unchanged — the prompt queue,
 the standalone board-change lane with all its damping, the idle review, the alive-ping, and the
@@ -349,9 +362,9 @@ than read from `.agent-modeling-kit/CLAUDE.md`. `--max-agents` has nothing to ca
 
 Give it room: the platform's MCP tool schemas alone run to ~16k tokens, so Ollama's default
 `num_ctx` of 4096 would silently truncate the tool block and leave the model inventing tool
-names. The runner raises it to 32768 by default (`LOCAL_AI_NUM_CTX`) and warns when the schemas
+names. The runner raises it to 49152 by default (`LOCAL_AI_NUM_CTX`) and warns when the schemas
 still fill more than 60% of it. On an OpenAI-compatible server the context is fixed at launch
-instead, so start it accordingly (vLLM: `--max-model-len 32768`, llama.cpp: `-c 32768`) —
+instead, so start it accordingly (vLLM: `--max-model-len 49152`, llama.cpp: `-c 49152`) —
 overflow there surfaces as an HTTP 400, which the runner reports with that advice attached.
 A turn is capped at 24 tool iterations, which ends a model that has lost the plot without
 ending the session.
@@ -361,6 +374,44 @@ different thing, and `anthropicBaseUrl` below is that path — but note that it
 speaking Anthropic's own `/v1/messages`, which Ollama does not serve. Pointing it straight at
 `localhost:11434` gets you a 404; a translating proxy has to sit in between.
 
+### Running headless, in a container
+
+`run` normally confirms which board it is about to drive and where that board's credentials
+come from. Those questions are worth one keystroke at a terminal and fatal anywhere else, so
+`--non-interactive` turns them off: the board and credentials that resolve from flags,
+`EVENTMODELERS_*` env vars and the config files are taken as final, and an incomplete set fails
+the run with the reason instead of being interviewed for.
+
+A missing TTY already implied this, which covers CI and most process supervisors — but not a
+container started with `-it`, or a loop started from a terminal: stdin is a TTY nobody is
+watching, and the run stops on a question forever. Pass the flag rather than relying on how
+stdin happens to be wired.
+
+```bash
+docker run --rm \
+  -e EVENTMODELERS_TOKEN=<token> \
+  -e EVENTMODELERS_ORGANIZATION_ID=<uuid> \
+  -e EVENTMODELERS_BOARD_ID=<uuid> \
+  -e LOCAL_AI_URL=http://host.docker.internal:11434 \
+  node:20 npx -y @eventmodelers/cli run --standalone --local-ai --non-interactive
+```
+
+Two things a container needs that a laptop already had:
+
+- **A writable `HOME`.** With no kit in the working directory the agent installs one under
+  `~/.eventmodelers/kit` and keeps per-board credentials in `~/.eventmodelers/boards/` (`0600`,
+  in a `0700` directory). Run as a user whose home exists and is writable, or mount a volume
+  there to keep the kit across restarts instead of reinstalling it on every boot.
+- **A reachable model server.** `localhost` inside the container is the container, not the host
+  — point `LOCAL_AI_URL` at `host.docker.internal` (Docker Desktop), the host's LAN address, or
+  the service name if Ollama/vLLM is a sibling container.
+
+`EVENTMODELERS_TOKEN` now also answers the credentials question on its own, the way
+`EVENTMODELERS_BOARD_ID` always answered the board question — an env var that wins over every
+config file anyway makes asking where the credentials come from moot. So a fully env-driven run
+is silent even without the flag; pass it anyway, so a half-set environment fails loudly instead
+of waiting for an answer.
+
 ### Installing skills globally
 
 By default, skills are copied into the project's own `.claude/skills/`. Pass `--global` to `init` or `init-modeling` to install them into `~/.claude/skills/` instead — available in every project without re-running the installer each time:

package/RELEASE_NOTES.md

@@ -1,7 +1,9 @@
 ## Unreleased
 
 ### Features
-- `run --modeling`/`run --standalone` accept `--local-ai`, so the modeling agent can be driven by a local or self-hosted model instead of Claude. It was previously rejected as a build-kit-only flag, which conflated two different things: `--bash`/`--exec` select a *queue* the modeling loop has no equivalent of, while `--local-ai` selects a *model*. Both wire dialects are supported — `--local-ai` (bare) or `--local-ai ollama` for Ollama's native `POST /api/chat`, and `--local-ai vllm`/`lmstudio`/`llamacpp` for the OpenAI-compatible `POST /v1/chat/completions` that vLLM, LM Studio, llama.cpp-server, TGI and SGLang serve; anything else OpenAI-compatible works via `LOCAL_AI_URL`. The loop itself is untouched: the prompt queue, the standalone board-change lane and its damping, the idle review and the platform's full MCP tool set all behave as before, because everything Claude-specific already sat behind a single `runTurn(text)` seam. What a local model cannot bring along is the part that is not a wire format — the skills (`/place-element`, `/timeline`, `eventmodeling-*`) and the subagent fan-out are Claude Code features — so a self-directed turn does the most valuable piece of work itself, inline, and the board rules it needs come from the new runner's system prompt (`lib/modeling-local-ai.js`) instead of `.agent-modeling-kit/CLAUDE.md`. `--max-agents` is ignored in this mode. Ollama's `num_ctx` is raised to 32768 by default (the MCP tool schemas alone are ~16k tokens, well past Ollama's 4096 default, which would silently truncate the tool block), with a warning when the schemas still fill >60% of it and a turn cap of 24 tool iterations.
+- `run --modeling`/`run --standalone` accept `--local-ai`, so the modeling agent can be driven by a local or self-hosted model instead of Claude. It was previously rejected as a build-kit-only flag, which conflated two different things: `--bash`/`--exec` select a *queue* the modeling loop has no equivalent of, while `--local-ai` selects a *model*. Both wire dialects are supported — `--local-ai` (bare) or `--local-ai ollama` for Ollama's native `POST /api/chat`, and `--local-ai vllm`/`lmstudio`/`llamacpp` for the OpenAI-compatible `POST /v1/chat/completions` that vLLM, LM Studio, llama.cpp-server, TGI and SGLang serve; anything else OpenAI-compatible works via `LOCAL_AI_URL`. The loop itself is untouched: the prompt queue, the standalone board-change lane and its damping, the idle review and the platform's full MCP tool set all behave as before, because everything Claude-specific already sat behind a single `runTurn(text)` seam. What a local model cannot bring along is the part that is not a wire format — the skills (`/place-element`, `/timeline`, `eventmodeling-*`) and the subagent fan-out are Claude Code features — so a self-directed turn does the most valuable piece of work itself, inline, and the board rules it needs come from the new runner's system prompt (`lib/modeling-local-ai.js`) instead of `.agent-modeling-kit/CLAUDE.md`. `--max-agents` is ignored in this mode. Ollama's `num_ctx` is raised to 49152 by default (the MCP tool schemas alone are ~16k tokens, well past Ollama's 4096 default, which would silently truncate the tool block), with a warning when the schemas still fill >60% of it and a turn cap of 24 tool iterations.
+
+- `run --non-interactive` never asks anything: the board and credentials that resolve from flags, `EVENTMODELERS_*` env vars and the config files are final, and an incomplete set fails the run with the reason instead of being interviewed for. A missing TTY already implied this, which covered CI and most supervisors, but not a container started with `-it` or a loop started from a terminal — stdin is a TTY nobody is watching, and the run stopped on the board confirmation or the credentials question forever. `EVENTMODELERS_TOKEN` also now answers the credentials question on its own, the way `EVENTMODELERS_BOARD_ID` always answered the board question: an env var that outranks every config file makes asking where the credentials come from moot. The README gains a container recipe, including the two things a container needs that a laptop already had — a writable HOME for the global kit and per-board credentials, and a `LOCAL_AI_URL` that isn't `localhost`.
 
 ### Docs
 - The `anthropicBaseUrl` option no longer implies Ollama works behind it. That route keeps Claude Code and swaps only the endpoint, so the server has to speak Anthropic's own `/v1/messages`; Ollama does not, and pointing it at `localhost:11434` returns a 404. For Ollama, `--local-ai` is the supported route, and the README now says which of the two to reach for.

package/cli.js

@@ -1568,10 +1568,22 @@ async function fetchDefaultBoardId(baseUrl, token) {
 // .eventmodelers/config.json up the tree beat ~/.eventmodelers/config.json. So
 // `run --standalone --board-id <uuid>` is enough for a board used before, and any run can
 // be pointed somewhere else entirely with --token/--organization-id.
-async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print) {
+async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print, nonInteractive = false) {
   const walked = loadEffectiveConfig(cwd, null, explicitConfigPath).config;
   const explicit = Object.fromEntries(Object.entries(flags ?? {}).filter(([, v]) => v));
 
+  // Whether there is anyone to ask, decided once. A TTY was the only signal before, which is
+  // right for a supervisor or CI (no stdin, so nothing to ask) but wrong for a loop started
+  // from a terminal: stdin is a TTY nobody is watching, and the run stops on a question.
+  // --non-interactive says so explicitly; --print never asks either.
+  const interactive = !print && !nonInteractive && process.stdin.isTTY;
+
+  // An EVENTMODELERS_TOKEN set for this run answers the credentials question below as
+  // squarely as --token does — applyEnvOverrides makes it win over every file anyway, so
+  // asking where this board's credentials come from could not change the outcome. The board
+  // question has always treated its env var this way; this is the same rule for the token.
+  const credentialsNamed = !!(explicit.token || process.env.EVENTMODELERS_TOKEN);
+
   // Which board comes first — everything else is stored per board, so there is nothing to
   // look up until we know which board this run is for.
   let boardId = explicit.boardId || process.env.EVENTMODELERS_BOARD_ID || walked.boardId || null;
@@ -1583,7 +1595,7 @@ async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print)
   // non-interactive stdin such as CI or a process supervisor), where the resolved value
   // stands on its own exactly as before.
   let boardChosen = !!(explicit.boardId || process.env.EVENTMODELERS_BOARD_ID);
-  if (!boardChosen && !print && process.stdin.isTTY) {
+  if (!boardChosen && interactive) {
     const answer = await prompt(boardId ? `\n  Board ID [${boardId}]: ` : '\n  Board ID: ');
     if (answer) {
       boardId = answer;
@@ -1613,7 +1625,7 @@ async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print)
   // implied — explicit credentials on the command line — or when there is no one to ask:
   // --print, or a non-interactive stdin such as CI or a supervisor that would otherwise
   // hang here forever (those keep using whatever is on file, silently).
-  if (!print && !explicit.token && process.stdin.isTTY) {
+  if (interactive && !credentialsNamed) {
     const hasAccountWide = !!(walked.token && walked.organizationId);
 
     // What "keep" would keep. A pointer entry is deliberately not offered: it says the
@@ -1678,9 +1690,10 @@ async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print)
     : { ...applyEnvOverrides({ ...walked, ...stored }), ...explicit };
   if (boardId) config.boardId = boardId;
 
-  if (!config.token || !config.organizationId) {
+  if ((!config.token || !config.organizationId) && interactive) {
     // Nothing anywhere — ask once, and save it account-wide rather than into this
-    // directory, so every later run from anywhere is silent.
+    // directory, so every later run from anywhere is silent. Headless, there is nobody to
+    // interview, so this is skipped and the check below fails the run with the reason.
     console.log('🔐 No Eventmodelers credentials found — configuring them once, account-wide.\n');
     config = await configureCredentials({
       config,
@@ -3107,6 +3120,7 @@ credentialFlags(program
   .option('--exec [command]', 'Hand each prompt to an external agent command instead of the default Claude runner, via ralph-exec.js (build-kit stacks only) — for agentic harnesses that bring their own tool loop, e.g. "codex exec --full-auto" or "opencode run". The prompt is appended as a quoted argument and also written to the file named by RALPH_PROMPT_FILE. Bare --exec uses localAi.exec from .eventmodelers/config.json. Claude remains the default when this flag is absent.')
   .option('--bash', 'Use the bash-only ralph.sh loop (build-kit stacks only, no realtime)')
   .option('--modeling', 'Keep one Claude process warm across prompts instead of spawning a fresh one per task, for low-latency voice/live use. Runs from a modeling-kit install in this directory, or from the global install (~/.eventmodelers/kit) when there is none. Built into the CLI, not a per-project file.')
+  .option('--non-interactive', 'Never ask anything: take the board and credentials that resolve from flags, EVENTMODELERS_* env vars and the config files, and fail with the reason if they are incomplete instead of interviewing for them. A TTY was previously the only signal — right for CI or a supervisor, wrong for a loop started from a terminal, where stdin is a TTY nobody is watching and the run stops on a question. Only affects the modeling loop (--modeling/--standalone/--global).')
   .option('--standalone', 'Let the modeling agent work the board in the background, on its own initiative: on top of direct prompts it subscribes to the board\'s change channel (like the build agents do) and, whenever the board goes quiet after an edit — or has simply been idle for a while — it takes a turn nobody asked for. Changed nodes are a notification, not the task: it judges the model as a whole and fans the work out over parallel subagents, one per changed area (examples on a new node, specs for a new command or read model, a missing attribute along a chain, a screen, a question comment). Filling that detail in while the human keeps modeling is the point — it does not wait for the board to be finished. Implies --modeling.')
   .option('--max-agents <n>', 'Cap how many subagents a self-directed --standalone turn may dispatch at once, to bound what an unattended agent can spend per turn. The agent merges work that shares a slice or chain first, then takes the most valuable pieces up to this many and leaves the rest for a later turn. 1 makes it do the single most valuable piece itself, without spawning anything. Default 5. Ignored without --standalone — prompt turns are one piece of work by definition.', '5')
   .option('--exclusive', 'Work only the prompts addressed to this agent\'s id — the board\'s "preferred agent" (the star in the prompts panel) — and hand every untargeted prompt straight back to the queue for another agent to take. Without it an agent also works everything nobody addressed to anyone, which is what you want for a single agent and exactly what you do not want for a dedicated one (a board with a general agent plus a specialist, or an agent a supervisor drives by id). Pair it with --id so the same agent is addressable across restarts — --global/--standalone otherwise mint a fresh id per run, and prompts addressed to the previous run\'s id are never claimed. Leaves --standalone alone: a self-directed turn is nobody\'s prompt, so an exclusive standalone agent still works the board on its own initiative.')
@@ -3201,7 +3215,7 @@ credentialFlags(program
           ...(opts.credentials ? parseCredentialsArg(opts.credentials) : {}),
           ...Object.fromEntries(Object.entries(credentialOverridesFromOpts(opts)).filter(([, v]) => v)),
         };
-        const config = await resolveModelingCredentials(cwd, flags, globalOpts.config, globalOpts.print);
+        const config = await resolveModelingCredentials(cwd, flags, globalOpts.config, globalOpts.print, !!opts.nonInteractive);
         projectDir = await ensureGlobalKit(config.baseUrl);
         kitDir = join(projectDir, MODELING_KIT.kitDirName);
         overrides = config;

package/lib/modeling-local-ai.js

@@ -47,7 +47,7 @@ const PRESETS = {
 };
 
 const DEFAULT_MODEL = 'qwen3.5:9b';
-const DEFAULT_NUM_CTX = 32768;
+const DEFAULT_NUM_CTX = 49152;
 // A modeling turn is read-then-write (get_nodes, then a placement or a field change),
 // so it needs more round trips than the build kit's 12 — but a local model that has
 // lost the plot loops on one tool forever, and this is what ends that turn instead of
@@ -77,7 +77,22 @@ export function resolveLocalAiTarget({ target, localAi = {} } = {}) {
     throw new Error(`Unknown local-AI dialect "${dialect}" — one of: ${Object.keys(DIALECTS).join(', ')}`);
   }
 
-  const rawCtx = process.env.LOCAL_AI_NUM_CTX || localAi.numCtx;
+  // Configured the same way every other knob here is: env wins over config.json's `localAi`,
+  // and the default stands when neither says otherwise. Validated rather than coerced, because
+  // Number('32k') is NaN, which JSON.stringify turns into `num_ctx: null` — a request Ollama
+  // accepts and silently answers with its own 4096 default, which is the exact failure the
+  // default below exists to prevent.
+  const rawCtx = process.env.LOCAL_AI_NUM_CTX ?? localAi.numCtx;
+  let numCtx = DEFAULT_NUM_CTX;
+  if (rawCtx !== undefined && rawCtx !== null && String(rawCtx).trim() !== '') {
+    numCtx = Number(rawCtx);
+    if (!Number.isInteger(numCtx) || numCtx <= 0) {
+      throw new Error(
+        `Invalid context size "${rawCtx}" (LOCAL_AI_NUM_CTX or localAi.numCtx) — a positive whole number of tokens, e.g. ${DEFAULT_NUM_CTX}`,
+      );
+    }
+  }
+
   return {
     url,
     dialect,
@@ -87,7 +102,7 @@ export function resolveLocalAiTarget({ target, localAi = {} } = {}) {
     // num_ctx is per-request in Ollama and its default (4096) is far below what the
     // MCP tool schemas alone need; on an OpenAI-compatible server the context is fixed
     // at launch, so there is nothing to send and overflow surfaces as an HTTP 400.
-    numCtx: dialect === 'ollama' ? (rawCtx ? Number(rawCtx) : DEFAULT_NUM_CTX) : null,
+    numCtx: dialect === 'ollama' ? numCtx : null,
   };
 }
 
@@ -200,7 +215,7 @@ export function createModelingLocalAiRunner({ cfg, target, log, verbose = false,
         throw new Error(
           `${t.dialect} HTTP 400 — the request exceeds the server's context window. The MCP tool schemas alone ` +
             `are ~${approxTokens(tools)} tokens; restart the server with a larger context ` +
-            `(vLLM: --max-model-len 32768, llama.cpp: -c 32768).\n${text.slice(0, 300)}`,
+            `(vLLM: --max-model-len 49152, llama.cpp: -c 49152).\n${text.slice(0, 300)}`,
         );
       }
       throw new Error(`${t.dialect} HTTP ${res.status}: ${text.slice(0, 300)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventmodelers/cli",
-  "version": "1.0.79",
+  "version": "1.0.80",
   "description": "Eventmodelers CLI — real-time Claude agent + skills for Claude Code, for any stack (Node, Supabase, Axon, OpenCQRS, UmaDB, Kurrent, or modeling-only)",
   "type": "module",
   "bin": {