@asobacloud/nehanda 0.4.0 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # Nehanda Command-Line Interface (`nehanda-cli`)
 
-An agentic terminal REPL and single-process engine built for governed AI deep research and software development. `nehanda-cli` connects directly to our flagship [Nehanda v3](https://huggingface.co/asoba/nehanda-v3-27b), as well as local or cloud-based Ollama models, LM Studio instances, or any OpenAI-compatible API.
+An agentic terminal REPL and single-process engine built for energy systems research and software development. `nehanda-cli` connects directly to our flagship [Nehanda v3](https://huggingface.co/asoba/nehanda-v3-27b), normalizes multi-OEM energy telemetry through the ODSE protocol, and enforces a governed development workflow across the full research-to-production lifecycle. It also connects to local or cloud-based Ollama models, LM Studio instances, or any OpenAI-compatible API.
 
 Every conversation turn, tool call, phase transition, and permission check is stored in a local, queryable SQLite database you own, ensuring complete transcripts exist for auditing and debugging.
 
@@ -83,12 +83,26 @@ To connect to an Ollama instance running on your network:
 
 * **In-Process Engine:** Executes turns directly inside the process via `runUserTurn`, eliminating separate server daemons or background HTTP relays.
 
-* **Jev-Mem Memory Architecture:** Every turn, a System-1 control plane ([Laya](https://huggingface.co/convaiinnovations/laya)) classifies observations into a multi-relational memory graph (semantic / temporal / causal / entity edges), then adaptively retrieves evidence before each model call. System-2 receives a compact canonical header + retrieved evidence + last 2 turns, not a raw transcript — cutting prefill 70–85% on long sessions. See [Jev-Mem Architecture](#jev-mem-architecture) below.
+* **ODSE Energy Normalization:** `lib/energy-middleware.mjs` intercepts MCP tool results from energy data servers and automatically normalizes them to the ODS-E protocol before the model sees the payload. OEM brand is resolved from the MCP server name (e.g. `energy-huawei` → `huawei`) or inferred by field-signature fingerprinting across 20+ OEM schemas (Huawei FusionSolar, Enphase, SolarEdge, Fronius, Sungrow, SMA, Eskom, and others). Multi-channel SCADA arrays and inverter state records render as box-drawing terminal tables with column headers and row-count summaries rather than raw JSON dumps.
+
+* **Jev-Mem Memory Architecture:** Every turn, a System-1 control plane ([Laya](https://huggingface.co/convaiinnovations/laya)) classifies observations into a multi-relational memory graph (semantic / temporal / causal / entity edges), then adaptively retrieves evidence before each model call. System-2 receives a compact canonical header + retrieved evidence + last 2 turns, not a raw transcript — cutting prefill 70–85% on long sessions. Domain invariants (ODSE schema mappings, asset capacity limits, simulation bounds) are pinned in the `pinned_context` table and reattached verbatim before every System-2 prompt, preventing model drift and hallucinated parameters across arbitrarily long research sessions. See [Jev-Mem Architecture](#jev-mem-architecture) below.
+
+  **Compaction entry scoring (Gap B, #4):** When the Jev-Mem compaction falls back to the prose summarizer, `scoreTranscriptEntries` scores old `tool_result` entries for relevance to the current task using Laya `scoreCandidate`. Entries with relevance < 0.25 are excluded from the distillation window. The last 6 entries are always kept. This operates on the fallback path only — memory-graph-level pruning (filtering `retrieveEvidence` output) requires a `session_prune_score` schema extension tracked in a follow-on issue; see `docs/MAP.md §Gap B`.
+
+  **Intent-driven instruction shaping (Gap C, #4):** Before each System-2 call in `idle`/`explore` phases, a 3-question Laya classification (`task_domain`, `task_scope`, `requires_domain_context`) runs on the user message. The result is injected as a `[TASK CONTEXT — System 1]` preamble into the system prompt, giving lower-parameter models (Nehanda 27B, DeepSeek Coder) precise task framing before generation begins rather than relying on them to infer intent from a generic prompt.
 
 * **Dynamic Tool Rescue (`[TOOL_CALL]`):** Native support for endpoints that strip OpenAI tool schemas (such as `nehandaMlProxy`). The engine dynamically injects active tool schemas directly into system prompts as `[TOOL_CALL]` blocks, parsing and executing tools locally without server-side function-calling support. Uses `[TOOL_CALL]` delimiters instead of `<tool_call>` XML to prevent vLLM's `--tool-call-parser qwen3_xml` stop-token interception.
 
 * **Deterministic SDLC Workflow:** Enforces a 6-phase state machine (`idle` → `plan` → `implement` → `test` → `verify` → `done`) to prevent unapproved code changes, hallucinated test passes, or unverified implementations.
 
+* **Interactive Safety Interventions:** When execution checkers flag a command — opening local sockets, inspecting HIL testbed hardware paths, or writing outside the working directory — the engine raises a structured `{ status, reason, risk_score, proposed_remediation }` payload rather than crashing. In the TUI, blocked operations surface a `BlockConfirmMenu` (`[A] Approve for Session | [S] Run in Laya Sandbox | [C] Cancel`) wired directly into the Ink event loop. Session approvals are cached so the same operation is not re-prompted within a session. Headless pipe mode auto-denies without prompting.
+
+  **Laya second-stage gate (Gap A, #4):** For `medium-risk` blocked commands, a Laya `noul` question (`is_safe_to_auto_approve`) runs before raising `BlockConfirmMenu`. If Laya returns `≥ 0.85` confidence the command is benign, it is auto-approved and cached without operator prompt. `high-risk` commands always bypass Laya and go directly to `BlockConfirmMenu`. Degraded Laya falls through to existing behavior — no regression. Implementation uses a flag variable (`layaAutoApproved`) rather than extracting the bash execution path into a named helper; see `docs/MAP.md §Gap A` for rationale.
+
+* **Runtime Visibility:** `RuntimeHealthMonitor` probes active inference endpoints (1s HEAD request) and checks Laya sidecar liveness before each session. The TUI status header shows active model, endpoint health and latency, sidecar PID, and context usage percentage — so researchers have immediate visual confirmation of whether the target backend is an internal local host or an external cloud endpoint before uploading grid telemetry.
+
+* **Process Legibility:** Every tool call is visible while it runs. Tool-start lines show argument summaries (`⚙ Read(ui.mjs)`, `⚙ Bash(git status)`), a live spinner with plain-English verbs tracks activity between outputs (`⠋ Analyzing…`, `⠙ Reading ui.mjs…`), and tool results carry honest context suffixes (`✓ Read: … (N lines)`, `✓ Bash: … (240ms)`, `✓ Write: … (N chars)`) — never fabricated data. A dim `esc to cancel` hint stays available while a turn runs, and result previews are capped at 120 characters so raw output never floods the screen. Backed by `summarizeToolArgs`, `verbForTool`, `formatToolResultSuffix`, and `TOOL_VERBS` in `lib/ui.mjs`, with a live spinner channel (`bridge.updateSpinner`) in the Ink TUI.
+
 * **Interactive TUI & Pipe Support:** Rich Ink-based TUI (`bin/nehanda-ui.mjs`) for interactive development sessions, with headless pipe-mode support (`bin/agent.mjs`) for acceptance testing and automation.
 
 * **Multi-Provider Switching:** Seamlessly switch between Nehanda 27B, local LM Studio, Ollama instances over LAN, Anthropic Claude, or any OpenAI-compatible API using `/model`.
@@ -103,10 +117,62 @@ To connect to an Ollama instance running on your network:
 
 ---
 
+## ODSE Energy Normalization
+
+`lib/energy-middleware.mjs` sits between MCP tool responses and the model. When an energy data MCP server returns a payload, the middleware resolves the OEM brand and normalizes the data to the [ODS-E](https://ona-protocol.org) schema via `lib/scripts/odse-transform.py` before the model sees it. This means the model always works with a consistent normalized schema regardless of which inverter brand, BESS, or SCADA system the data originated from.
+
+### OEM Detection
+
+Brand resolution happens in two passes:
+
+1. **Name-based:** The MCP server name is parsed for a known OEM key. `energy-huawei`, `mcp-solaredge`, `power-sungrow-v2` all resolve correctly. Any prefix before the OEM segment is stripped.
+2. **Payload fingerprinting:** If the server name doesn't resolve, field signatures are matched against known schemas — e.g. `{ inverter_state, run_state }` → Huawei FusionSolar; `{ end_at, wh_del, devices_reporting }` → Enphase Envoy; `{ data: { telemetries } }` → SolarEdge.
+
+If neither pass identifies the OEM, the payload is returned unchanged (pass-through).
+
+### Supported OEMs
+
+Huawei FusionSolar, Enphase Envoy, SolarEdge, Fronius, Solarman, SMA, Solis, Sungrow / iSolarCloud, Sungrow BESS / PowerTitan, BYD BESS, Fimer / AuroraVision, SolaxCloud, Eskom (portal, AMR, NRS049), Vestas, Siemens Gamesa, Nordex, Terraco, and generic CSV.
+
+### MCP Server Naming Convention
+
+Name energy MCP servers with the OEM as a segment in the server name:
+
+```json
+{
+  "mcpServers": {
+    "energy-huawei": { "command": "...", "args": ["..."] },
+    "energy-solaredge": { "command": "...", "args": ["..."] }
+  }
+}
+```
+
+No additional configuration is required — normalization is automatic.
+
+### `odse-transform.py` Output Formats
+
+The transform script accepts a `--format` flag for direct use:
+
+```bash
+echo '<payload>' | python3 lib/scripts/odse-transform.py --source huawei --format table
+echo '<payload>' | python3 lib/scripts/odse-transform.py --source solaredge --format ndjson
+echo '<payload>' | python3 lib/scripts/odse-transform.py --source sungrow --format summary
+```
+
+| Format | Output | Default when |
+|---|---|---|
+| `table` | Box-drawing ASCII table with column headers and row count | stdout is a TTY |
+| `ndjson` | One JSON object per line | stdout is piped |
+| `summary` | Metadata header (`rows`, `shape`, `source`) + JSON array | explicit flag only |
+
+---
+
 ## Jev-Mem Architecture
 
 `nehanda-cli` implements the memory architecture from **"System-One-Controlled Agentic Memory for Efficient AI Agents"** (Jiang, Li & Li, UT Dallas — [arXiv:2609.23986](https://arxiv.org/abs/2609.23986)). The core insight: the frequent, structured decisions of memory management — typing, relation judgment, retrieval routing, sufficiency assessment — don't need an autoregressive LLM. They need a fast, calibrated System-1 model.
 
+In the context of energy systems research, this matters directly: long multi-step sessions involving SCADA data ingestion, grid simulation, and iterative code generation accumulate enough context to trigger compaction. Standard sliding-window compaction indiscriminately discards ODSE schema mappings, asset capacity limits, and simulation bounds alongside routine tool outputs — causing the model to hallucinate parameters on subsequent turns. Jev-Mem's pinned context layer prevents this: domain invariants are stored in `pinned_context` and reattached verbatim before every System-2 prompt, surviving arbitrarily many compaction cycles.
+
 The System-1 control plane is [**Laya**](https://huggingface.co/convaiinnovations/laya) — a 421M-parameter, non-autoregressive decision model (open weights, Apache 2.0) that answers typed questions in a single forward pass (~33 ms on GPU, ~200 ms on CPU). It never generates text, so there is nothing to parse and nothing to hallucinate.
 
 ```
@@ -135,6 +201,7 @@ Observation (user / tool / assistant turn)
         │
         ▼
 ┌── SYSTEM 2 PROMPT ────────────────────────────────────────────┐
+│  [PINNED DOMAIN INVARIANTS]  (ODSE schema, asset specs, ...)  │
 │  [CANONICAL SYSTEM 1 STATE]  (task_status, file_target, ...)  │
 │  [RETRIEVED EVIDENCE]  (top-K memories, not raw transcript)   │
 │  last 2 turns + last failed tool result                       │
@@ -164,7 +231,7 @@ On first startup, `lib/scripts/ensure-laya-env.sh` creates a dedicated venv at `
 
 ### Memory plane (SQLite)
 
-The memory plane extends the existing `memories` table and adds `memory_edges` and `laya_jev_state`. All data lives in the same local SQLite database as the rest of the session state (`~/.config/nehanda/ona-session.db`).
+The memory plane extends the existing `memories` table and adds `memory_edges`, `laya_jev_state`, and `pinned_context`. All data lives in the same local SQLite database as the rest of the session state (`~/.config/nehanda/ona-session.db`).
 
 | Table | Purpose |
 |---|---|
@@ -172,6 +239,7 @@ The memory plane extends the existing `memories` table and adds `memory_edges` a
 | `memories_fts` | FTS5 index over memory content for lexical anchor retrieval |
 | `memory_edges` | Multi-relational edges — same node pair may have independent semantic, temporal, causal, and entity edges |
 | `laya_jev_state` | Session control block: `task_status`, `file_target`, `escalation_risk`, `confidence_score` |
+| `pinned_context` | Session-scoped domain invariants keyed by string — ODSE schema mappings, asset specs, simulation bounds. Never distilled by compaction; reattached verbatim before every System-2 prompt. |
 
 ---
 
@@ -388,6 +456,7 @@ Session state is persisted locally at `~/.config/nehanda/ona-session.db`. Key ta
 * `memories`: Jev-Mem canonical node store with overlapping type scores and entity provenance.
 * `memory_edges`: Multi-relational graph edges (semantic / temporal / causal / entity).
 * `laya_jev_state`: System-1 session control block (task_status, file_target, escalation_risk).
+* `pinned_context`: Session-scoped domain invariants (ODSE schema mappings, asset specs, simulation bounds) that survive compaction unchanged.
 
 ---
 
@@ -414,10 +483,36 @@ node tests/unit/compact_jev_behavioral.mjs
 node tests/unit/orchestrate_jev_hotpath_behavioral.mjs
 ```
 
+Run the UX improvement behavioral suites:
+
+```bash
+node tests/unit/gap1_runtime_visibility_behavioral.mjs
+node tests/unit/gap2_output_formatting_behavioral.mjs
+node tests/unit/gap3_safety_intervention_behavioral.mjs
+node tests/unit/gap4_pinned_compaction_behavioral.mjs
+node tests/unit/ui_legibility_behavioral.mjs
+```
+
 ---
 
 ## Changelog
 
+### 0.6.0
+
+- **Provider API Key Management (`lib/auth.mjs`, `lib/orchestrate.mjs`, `bin/nehanda-ui.mjs`):** OpenRouter, ZhipuAI (z.ai), and generic OpenAI-compatible providers can now be configured entirely from within the REPL. `/key openrouter sk-or-v1-...` saves the key to the secure file and auto-sets `base_url`. `/key zhipu sk-zai-...` saves the ZhipuAI key. `/config` now shows compat and Zhipu key status (masked). Fixes a pre-existing gap where `resolveZhipuApiKey()` existed in `lib/auth.mjs` but was never called by the orchestrator — the `zhipu` provider fell through to `OPENAI_API_KEY`. Closes #1.
+
+- **Laya System-1 Bashguard Gate (`lib/tools.mjs`):** Medium-risk blocked shell commands now pass through a Laya `noul` question (`is_safe_to_auto_approve`) before raising `BlockConfirmMenu`. Commands with ≥ 0.85 confidence are auto-approved and cached without operator prompt. High-risk commands always bypass Laya. Degraded Laya falls through unchanged. Implementation uses a flag variable (`layaAutoApproved`) — see `docs/MAP.md §Gap A`. Closes #4 (Gap A).
+
+- **Compaction Entry Scoring (`lib/compact.mjs`):** When Jev-Mem compaction falls back to the prose summarizer, `scoreTranscriptEntries` scores old `tool_result` entries for relevance to the current task via Laya `scoreCandidate`. Entries with relevance < 0.25 are excluded from the distillation window. Last 6 entries always kept. Operates on the fallback path only — memory-graph-level pruning deferred to a follow-on issue; see `docs/MAP.md §Gap B`. Closes #4 (Gap B).
+
+- **Intent-Driven Instruction Shaping (`lib/laya.mjs`, `lib/orchestrate.mjs`):** Before each System-2 call in `idle`/`explore` phases, a 3-question Laya classification (`task_domain`, `task_scope`, `requires_domain_context`) runs on the user message and injects a `[TASK CONTEXT — System 1]` preamble into the system prompt. Gives lower-parameter models (Nehanda 27B, DeepSeek Coder) precise task framing before generation. Null `intentMeta` produces no regression. Closes #4 (Gap C).
+
+- **`docs/MAP.md` created** — architectural reference for module contracts, design decisions, and follow-on work.
+
+### 0.5.1
+
+- **Process Legibility for Tool Calling (`lib/ui.mjs`, `lib/orchestrate.mjs`, `bin/nehanda-ui.mjs`):** The TUI now shows what the agent is doing while it works. Tool-start lines include argument summaries — `⚙ Read(ui.mjs)`, `⚙ Bash(git status)` — generated by the new `summarizeToolArgs` export (`lib/ui.mjs`), with tool input passed through the orchestration layer's `io.onToolStart(name, toolInput)` contract at both call sites (`lib/orchestrate.mjs`). A live spinner channel (`bridge.updateSpinner` in the Ink REPL, plus verb rotation in the `Spinner` class used by pipe mode) replaces the previous no-op stub, cycling plain-English activity verbs (`Analyzing`, `Thinking`, `Reading`, `Searching`, `Running`, …). Tool results gain honest context suffixes via `formatToolResultSuffix` (`lib/ui.mjs`): line counts for `Read`, character counts for `Write`, elapsed-time `(Nms)` for `Bash` — no fabricated exit codes. The `esc to cancel` hint and the 120-character result preview cap are now regression-protected. Behavioral coverage in `tests/unit/ui_legibility_behavioral.mjs` (15 scenarios, including an end-to-end turn against a fake OpenAI-compatible endpoint). Closes #2.
+
 ### 0.4.0
 - **Runtime Visibility (`lib/modelDiscovery.mjs`, `lib/ui.mjs`):** New `RuntimeHealthMonitor` class probes active inference endpoints (1s HEAD request, Kubernetes readiness pattern) and checks Laya sidecar liveness via `pgrep`. `renderStatusHeader` and `renderModelSwitchNotice` added to `lib/ui.mjs` — the TUI now shows active model, endpoint health + latency, sidecar PID, and context usage percentage after startup and on every `/model` switch.
 - **Structured Output Formatting (`lib/ui.mjs`, `lib/scripts/odse-transform.py`):** `formatToolResult` now detects JSON array payloads from tool responses and renders them as `cli-table3` box-drawing tables with column headers and row-count summaries (capped at 10 rows with overflow note), falling back to the plain-text preview for non-array content. `odse-transform.py` gains a `--format table|ndjson|summary` flag; defaults to `table` when stdout is a TTY and `ndjson` when piped.

package/bin/agent.mjs

@@ -9,7 +9,7 @@ import { stdin as input, stdout as output } from 'node:process'
 
 import { openStore } from '../lib/store.mjs'
 import { defaultDbPath } from '../lib/paths.mjs'
-import { resolveAnthropicCredentials, authStatusSummary, saveSecureCredentials, clearSecureCredentials, interactiveOAuthLogin } from '../lib/auth.mjs'
+import { resolveAnthropicCredentials, authStatusSummary, saveSecureCredentials, clearSecureCredentials, interactiveOAuthLogin, resolveOpenAiCompatKey, resolveZhipuApiKey } from '../lib/auth.mjs'
 import { bootstrapSettings, getEffectiveSettings, updateEffectiveSettings } from '../lib/settings.mjs'
 import { resolveWireModel, allModelIds, supportsCustomModels, supportsDiscovery } from '../lib/modelConfig.mjs'
 import { runHooks } from '../lib/hookplane.mjs'
@@ -889,7 +889,11 @@ async function mainPipe(opts) {
         settings = updateEffectiveSettings(db, patch)
         io.println(ui.colors.success(`  ✓ Set ${dotPath}`))
       } else {
-        io.println(ui.formatConfig(settings))
+        const keyStatus = {
+          compatKeySet: !!resolveOpenAiCompatKey(),
+          zhipuKeySet:  !!resolveZhipuApiKey(),
+        }
+        io.println(ui.formatConfig(settings, keyStatus))
       }
       continue
     }

package/bin/nehanda-ui.mjs

@@ -21,6 +21,8 @@ import { modelConfigFromAgent } from '../lib/modelConfig.mjs'
 import { applyMcpConfig, loadMcpConfig, writeGlobalMcpConfig, readGlobalMcpConfig, globalMcpConfigPath, updateMcpServerEnv } from '../lib/mcp-config.mjs'
 import { getMcpServer, closeAllMcpServers, listMcpServers, mcpListResources } from '../lib/mcp.mjs'
 import { invalidateMcpToolCache } from '../lib/tools.mjs'
+import { saveOpenAiCompatKey, resolveOpenAiCompatKey, saveSecureCredentials, resolveZhipuApiKey } from '../lib/auth.mjs'
+import { TOOL_VERBS, verbForTool, summarizeToolArgs, formatToolResultSuffix } from '../lib/ui.mjs'
 import Database from 'better-sqlite3'
 import { ensureLayaReady } from '../lib/laya_sidecar.mjs'
 
@@ -136,7 +138,7 @@ function renderMd(text) {
 const SPINNER_FRAMES = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏']
 const SLASH_COMMANDS = [
   { name: '/model',  desc: 'Change model endpoint' },
-  { name: '/key',    desc: 'Set Nehanda API key' },
+  { name: '/key',    desc: 'Set API key (/key, /key openrouter, /key zhipu, /key openai)' },
   { name: '/config', desc: 'Show current config' },
   { name: '/mcp',    desc: 'MCP server & tool management (/mcp list)' },
   { name: '/clear',  desc: 'New conversation' },
@@ -292,8 +294,12 @@ function MessageView({ msg }) {
 }
 function Spinner({ label }) {
   const [frame, setFrame] = React.useState(0)
-  React.useEffect(() => { const t = setInterval(() => setFrame(f => (f + 1) % SPINNER_FRAMES.length), 80); return () => clearInterval(t) }, [])
-  return e(Box, { marginLeft: 1 }, e(Text, { color: BRAND.accent }, SPINNER_FRAMES[frame] + ' '), e(Text, { dimColor: true }, label || 'Thinking…'))
+  React.useEffect(() => { const t = setInterval(() => setFrame(f => f + 1), 80); return () => clearInterval(t) }, [])
+  // Generic labels rotate plain-English verbs; specific labels (e.g. "Reading ui.mjs") stay static.
+  const verb = (!label || label === 'Thinking')
+    ? TOOL_VERBS[Math.floor(frame / 5) % TOOL_VERBS.length]
+    : label
+  return e(Box, { marginLeft: 1 }, e(Text, { color: BRAND.accent }, SPINNER_FRAMES[frame % SPINNER_FRAMES.length] + ' '), e(Text, { dimColor: true }, verb + '…'))
 }
 function SlashMenu({ filter }) {
   const matches = SLASH_COMMANDS.filter(c => c.name.startsWith(filter) || c.name.includes(filter.slice(1)))
@@ -404,6 +410,7 @@ function App({ bridge }) {
   const [selectState, setSelectState] = React.useState(null)
   const [blockState,  setBlockState]  = React.useState(null)
   const [callCount,  setCallCount]  = React.useState(0)
+  const [spinLabel,  setSpinLabel]  = React.useState(null)
   const [modelInfo,  setModelInfo]  = React.useState(() => {
     const data = readAgents()
     const ag = data.agents?.find(a => a.name === data.default_agent) || data.agents?.[0]
@@ -421,6 +428,7 @@ function App({ bridge }) {
     bridge.endAssistant   = msg  => { setFinalized(p => [...p, msg]); setStreaming(null); setCallCount(c => c + 1) }
     bridge.clearMessages  = ()   => { setFinalized([]); setStreaming(null); setClearGen(g => g + 1) }
     bridge.setLoading     = v    => setIsLoading(v)
+    bridge.updateSpinner  = text => setSpinLabel(text)
     bridge.ask    = q     => new Promise(resolve => setAskState({ question: q, resolve }))
     bridge.select = (t,i) => new Promise(resolve => setSelectState({ title: t, items: i, resolve }))
     bridge.confirmBlock = payload => new Promise(resolve => setBlockState({ payload, resolve }))
@@ -471,7 +479,7 @@ function App({ bridge }) {
         ? e(WelcomeBanner, { key: 'banner', model: modelInfo.model, endpoint: modelInfo.endpoint })
         : e(MessageView,   { key: String(i), msg: item })),
     streaming ? e(MessageView, { msg: { role: 'assistant', ...streaming } }) : null,
-    isLoading && (!streaming || !streaming.text) ? e(Spinner, {}) : null,
+    (isLoading && (!streaming || !streaming.text)) || spinLabel ? e(Spinner, { label: spinLabel || undefined }) : null,
     askState
       ? e(AskPrompt, { question: askState.question, onAnswer: handleAnswer, onCancel: handleAskCancel })
       : blockState
@@ -521,10 +529,14 @@ async function handleCommand(cmd, bridge) {
   if (name === '/config') {
     const data = readAgents()
     const ag   = data.agents?.find(a => a.name === data.default_agent) || data.agents?.[0]
+    const compatKeySet = !!resolveOpenAiCompatKey()
+    const zhipuKeySet  = !!resolveZhipuApiKey()
     bridge.addMessage({ role: 'system', text: [
-      '', `  Model:    ${chalk.hex(BRAND.accent)(ag?.model || '—')}`,
-      `  Endpoint: ${chalk.dim(ag?.endpoint || '—')}`,
-      `  API key:  ${readApiKey() ? chalk.green('set') : chalk.hex(BRAND.red)('not set')}`, '',
+      '', `  Model:             ${chalk.hex(BRAND.accent)(ag?.model || '—')}`,
+      `  Endpoint:          ${chalk.dim(ag?.endpoint || '—')}`,
+      `  Nehanda key:       ${readApiKey() ? chalk.green('set') : chalk.hex(BRAND.red)('not set')}`,
+      `  OpenAI-compat key: ${compatKeySet ? chalk.green('set') : chalk.dim('not set')}`,
+      `  Zhipu key:         ${zhipuKeySet  ? chalk.green('set') : chalk.dim('not set')}`, '',
     ].join('\n') })
     return
   }
@@ -540,10 +552,50 @@ async function handleCommand(cmd, bridge) {
   }
   if (name === '/exit' || name === '/quit') { bridge.exit(); process.exit(0) }
   if (name === '/key') {
-    const answer = await bridge.ask('New Nehanda API key:')
+    // Parse optional provider subcommand: /key [openrouter|zhipu|openai] [value]
+    const parts = cmd.trim().split(/\s+/)
+    const sub   = parts[1] || ''
+    const KNOWN_COMPAT_PROVIDERS = ['openrouter', 'openai', 'zhipu']
+
+    if (!sub || !KNOWN_COMPAT_PROVIDERS.includes(sub.toLowerCase())) {
+      // Default: Nehanda API key (existing behaviour, unchanged)
+      const answer = await bridge.ask('New Nehanda API key:')
+      if (!answer) return
+      try { writeApiKey(answer); bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} Nehanda API key updated.` }) }
+      catch (err) { bridge.addMessage({ role: 'error', text: 'Failed: ' + err.message }) }
+      return
+    }
+
+    const provider = sub.toLowerCase()
+    // Value may be provided inline (/key openrouter sk-...) or prompted
+    const inlineValue = parts.slice(2).join('').trim()
+    const answer = inlineValue || await bridge.ask(`New ${provider} API key:`)
     if (!answer) return
-    try { writeApiKey(answer); bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} API key updated.` }) }
-    catch (err) { bridge.addMessage({ role: 'error', text: 'Failed: ' + err.message }) }
+
+    try {
+      if (provider === 'zhipu') {
+        saveSecureCredentials({ zhipuApiKey: answer })
+        bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} Zhipu API key saved to secure storage.` })
+      } else {
+        // openrouter or openai — both use the openaiCompatApiKey slot
+        saveOpenAiCompatKey(answer)
+        if (provider === 'openrouter') {
+          // Auto-configure base_url and provider for OpenRouter
+          runtimeSettings.model_config = {
+            ...runtimeSettings.model_config,
+            base_url: 'https://openrouter.ai/api/v1',
+            provider: 'openai_compatible',
+          }
+          bridge.addMessage({ role: 'system', text: [
+            `  ${chalk.green('✓')} OpenRouter API key saved to secure storage.`,
+            `  ${chalk.green('✓')} Base URL set to ${chalk.dim('https://openrouter.ai/api/v1')}`,
+            `  ${chalk.dim('Use /model to select an OpenRouter model (e.g. openai_compatible/anthropic/claude-3.5-sonnet)')}`,
+          ].join('\n') })
+        } else {
+          bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} OpenAI-compat API key saved to secure storage.` })
+        }
+      }
+    } catch (err) { bridge.addMessage({ role: 'error', text: 'Failed: ' + err.message }) }
     return
   }
   if (name === '/model') {
@@ -819,6 +871,8 @@ bridge.onSubmit = async (text) => {
     let fullText = '', aborted = false
     controller.signal.addEventListener('abort', () => { aborted = true })
 
+    const toolStarts  = new Map()
+    const lastToolArgs = new Map()
     const io = {
       write(chunk) {
         if (aborted) return
@@ -827,14 +881,26 @@ bridge.onSubmit = async (text) => {
         bridge.updateAssistant(lastPartial)
       },
       println(msg)            { if (!aborted) bridge.addMessage({ role: 'system', text: '  ' + msg }) },
-      spinner:                { start() {}, stop() {} },
+      spinner: {
+        start: label => bridge.updateSpinner(label),
+        stop:  ()    => bridge.updateSpinner(null),
+      },
       ask:                    bridge.ask,
       confirmBlock:           payload => bridge.confirmBlock(payload),
-      onToolStart(name)       { if (!aborted) bridge.addMessage({ role: 'system', text: `  ⚙ ${name}` }) },
+      onToolStart(name, args) {
+        if (aborted) return
+        lastToolArgs.set(name, args)
+        toolStarts.set(name, Date.now())
+        const summary = summarizeToolArgs(name, args)
+        bridge.addMessage({ role: 'system', text: `  ⚙ ${name}${summary ? `(${summary})` : ''}` })
+        bridge.updateSpinner(verbForTool(name) + (summary ? ' ' + summary : ''))
+      },
       onToolResult(name, c, err) {
         if (aborted) return
         const preview = String(c || '').slice(0, 120).replace(/\n/g, ' ')
-        bridge.addMessage({ role: 'system', text: `  ${err ? '✗' : '✓'} ${name}: ${preview}` })
+        const suffix = formatToolResultSuffix(name, c, { startedAt: toolStarts.get(name), args: lastToolArgs.get(name) })
+        bridge.addMessage({ role: 'system', text: `  ${err ? '✗' : '✓'} ${name}: ${preview}${suffix}` })
+        bridge.updateSpinner(null)
       },
     }
 

package/lib/auth.mjs

@@ -109,16 +109,36 @@ function computeAlsoConfiguredHints(active, pref) {
   return { envBearer, envApiKey: envKey, secureFileBearer: fileB, secureFileApiKey: fileK, ignoredHints: ignored }
 }
 
-export function saveSecureCredentials({ apiKey, bearerToken, zhipuApiKey }) {
+export function saveSecureCredentials({ apiKey, bearerToken, zhipuApiKey, openaiCompatApiKey }) {
   const p = secureAuthPath()
   const prev = readSecureAuthFile() || {}
   const next = { ...prev }
   if (apiKey !== undefined) { if (apiKey === '') delete next.apiKey; else next.apiKey = apiKey }
   if (bearerToken !== undefined) { if (bearerToken === '') delete next.bearerToken; else next.bearerToken = bearerToken }
   if (zhipuApiKey !== undefined) { if (zhipuApiKey === '') delete next.zhipuApiKey; else next.zhipuApiKey = zhipuApiKey }
+  if (openaiCompatApiKey !== undefined) { if (openaiCompatApiKey === '') delete next.openaiCompatApiKey; else next.openaiCompatApiKey = openaiCompatApiKey }
   fs.writeFileSync(p, JSON.stringify(next, null, 0), { mode: 0o600 })
 }
 
+/** Save an OpenAI-compatible provider API key (OpenRouter, generic, etc.) to secure storage. */
+export function saveOpenAiCompatKey(key) {
+  saveSecureCredentials({ openaiCompatApiKey: key })
+}
+
+/**
+ * Resolve the API key for openai_compatible provider.
+ * Priority: OPENROUTER_API_KEY env → OPENAI_API_KEY env → secure file openaiCompatApiKey
+ * (Callers in orchestrate.mjs check model_config.api_key first, before calling this.)
+ */
+export function resolveOpenAiCompatKey() {
+  const fromOpenRouter = nonempty(process.env.OPENROUTER_API_KEY)
+  if (fromOpenRouter) return fromOpenRouter
+  const fromOpenAi = nonempty(process.env.OPENAI_API_KEY)
+  if (fromOpenAi) return fromOpenAi
+  const file = readSecureAuthFile()
+  return nonempty(file?.openaiCompatApiKey) || ''
+}
+
 export function resolveZhipuApiKey() {
   const fromEnv = nonempty(process.env.ZAI_API_KEY)
   if (fromEnv) return fromEnv
@@ -134,7 +154,12 @@ function readSecureAuthFile() {
   try {
     const raw = fs.readFileSync(secureAuthPath(), 'utf8')
     const j = JSON.parse(raw)
-    return { apiKey: nonempty(j.apiKey), bearerToken: nonempty(j.bearerToken), zhipuApiKey: nonempty(j.zhipuApiKey) }
+    return {
+      apiKey: nonempty(j.apiKey),
+      bearerToken: nonempty(j.bearerToken),
+      zhipuApiKey: nonempty(j.zhipuApiKey),
+      openaiCompatApiKey: nonempty(j.openaiCompatApiKey),
+    }
   } catch { return null }
 }
 

package/lib/compact.mjs

@@ -1,7 +1,7 @@
 import { appendEntry } from './transcript.mjs'
 import { withTransaction, getLayaJevState, upsertLayaJevState, getPinnedContextBlocks } from './store.mjs'
 import { runHooks } from './hookplane.mjs'
-import { extractCanonicalState } from './laya.mjs'
+import { extractCanonicalState, scoreCandidate, noulProb } from './laya.mjs'
 import {
   transcriptTailText,
   extractRecentFilePaths,
@@ -49,7 +49,21 @@ export async function compactConversation(db, rt, summarize, log) {
   try {
     summary = await buildJevCollapseSummary(db, rt, pinnedBlocks)
   } catch {
-    const text = entries.map(e => {
+    // Fallback summarizer path: score tool_result entries for relevance before
+    // assembling the distillation text. Low-relevance entries are excluded.
+    // Scope note: this gates the fallback path only. Memory-graph-level pruning
+    // (filtering what retrieveEvidence returns) requires a session_prune_score
+    // column in the memories table — tracked as a follow-on issue.
+    const taskContext = entries
+      .filter(e => e.entry_type === 'user')
+      .slice(-1)
+      .map(e => { try { return extractText(JSON.parse(e.payload_json)) } catch { return '' } })
+      .join('').slice(0, 200)
+
+    const scoredEntries = await scoreTranscriptEntries(entries, taskContext, rt.layaOpts || {})
+
+    const text = scoredEntries.map(e => {
+      if (e._prune) return ''
       try {
         const p = JSON.parse(e.payload_json)
         if (e.entry_type === 'user') return `User: ${extractText(p)}`
@@ -338,6 +352,47 @@ export async function buildJevSystem2Messages(db, rt, messages, opts = {}) {
   }
 }
 
+/**
+ * Score transcript entries for relevance to the current task using Laya System-1.
+ * Only scores tool_result entries older than SCORE_SKIP_RECENT turns.
+ * Entries below SCORE_PRUNE_THRESHOLD are marked _prune=true.
+ * Degraded Laya: all entries retain _prune=false (keep-all fallback — no data loss).
+ *
+ * Scope: gates the fallback summarizer path in compactConversation.
+ * Memory-graph-level pruning (filtering retrieveEvidence output) requires a
+ * session_prune_score column in the memories table — tracked as a follow-on issue.
+ *
+ * @param {Array} entries - transcript_entries rows with entry_type and payload_json
+ * @param {string} taskContext - short string describing the current task
+ * @param {object} layaOpts - passed through to queryLaya
+ * @returns {Promise<Array>} same entries array, each annotated with _relevance and _prune
+ */
+const SCORE_SKIP_RECENT = 6    // last N entries always kept, never scored
+const SCORE_MAX_ENTRIES = 20   // max tool_result entries scored per compaction
+const SCORE_PRUNE_THRESHOLD = 0.25  // relevance noul below this → prune
+
+export async function scoreTranscriptEntries(entries, taskContext = '', layaOpts = {}) {
+  const toScore = entries
+    .slice(0, Math.max(0, entries.length - SCORE_SKIP_RECENT))
+    .filter(e => e.entry_type === 'tool_result')
+    .slice(0, SCORE_MAX_ENTRIES)
+
+  for (const entry of toScore) {
+    try {
+      const p = JSON.parse(entry.payload_json)
+      const content = typeof p.content === 'string' ? p.content.slice(0, 400) : ''
+      const candidateText = `Task: ${taskContext}\nEntry: ${content}`
+      const result = await scoreCandidate(candidateText, { ...layaOpts, timeoutMs: 150 })
+      entry._relevance = result.relevance
+      entry._prune = !result.degraded && result.relevance < SCORE_PRUNE_THRESHOLD
+    } catch {
+      entry._relevance = 1    // on error: keep the entry
+      entry._prune = false
+    }
+  }
+  return entries
+}
+
 function extractText(payload) {
   const blocks = payload.content
   if (!Array.isArray(blocks)) return ''

package/lib/laya.mjs

@@ -85,6 +85,34 @@ export const SESSION_STATE_QUESTIONS = {
   },
 }
 
+export const INTENT_QUESTIONS = {
+  task_domain: {
+    type: 'choice',
+    instructions: 'What is the primary domain of this task?',
+    criteria: {
+      code_edit:      'writing, modifying, or refactoring source code files',
+      code_review:    'reading, explaining, or understanding existing code',
+      energy_data:    'ODSE telemetry, inverter, BESS, SCADA, or grid data',
+      infrastructure: 'deployment, CI/CD, environment config, Docker, AWS',
+      research:       'factual lookup, concept explanation, documentation',
+      test_debug:     'fixing a failing test, diagnosing an error or stack trace',
+    },
+  },
+  task_scope: {
+    type: 'choice',
+    instructions: 'How many files or components does this task likely affect?',
+    criteria: {
+      single_file:   'change confined to one file or function',
+      multi_file:    'change spans two to five files',
+      architectural: 'change affects interfaces, schemas, or multiple subsystems',
+    },
+  },
+  requires_domain_context: {
+    type: 'noul',
+    instructions: 'Does this task require energy domain knowledge (ODSE schema, OEM telemetry, asset specs)?',
+  },
+}
+
 /** Truncate from the end (most recent) to fit Laya's state budget. */
 export function truncateForLaya(text, budget = LAYA_STATE_CHAR_BUDGET) {
   if (!text) return ''
@@ -197,6 +225,19 @@ export function heuristicAnswers(questions, stateText = '') {
       else if (/\b(edit|write|patch|implement|search\/replace)\b/.test(t)) choice = 'modifying_code'
       else if (/\b(please confirm|awaiting|should i)\b/.test(t)) choice = 'awaiting_user'
       out[key] = { choice, confidence: 0.4 }
+    } else if (q.type === 'choice' && key === 'task_domain') {
+      let choice = 'code_edit'
+      if (/\b(odse|telemetry|inverter|huawei|solaredge|enphase|sungrow|bess|scada|kwh|grid|meter|oemid|fusionsolar)\b/.test(t)) choice = 'energy_data'
+      else if (/\b(test|fail|error|assert|stack trace|exception|debug)\b/.test(t)) choice = 'test_debug'
+      else if (/\b(deploy|docker|ci|cd|aws|lambda|infra|env|config|environment)\b/.test(t)) choice = 'infrastructure'
+      else if (/\b(explain|what is|how does|document|readme|concept)\b/.test(t)) choice = 'research'
+      else if (/\b(read|review|understand|look at|show me|what does)\b/.test(t)) choice = 'code_review'
+      out[key] = { choice, confidence: 0.4 }
+    } else if (q.type === 'choice' && key === 'task_scope') {
+      let choice = 'single_file'
+      if (/\b(schema|interface|protocol|architect|subsystem|refactor.*all|across)\b/.test(t)) choice = 'architectural'
+      else if (/\b(files|modules|multiple|several|both)\b/.test(t)) choice = 'multi_file'
+      out[key] = { choice, confidence: 0.4 }
     } else if (q.type === 'noul') {
       let p = 0.3
       if (key === 'escalation_risk' || key === 'blocked') p = /\b(error|fail|blocked)\b/.test(t) ? 0.7 : 0.2
@@ -205,6 +246,8 @@ export function heuristicAnswers(questions, stateText = '') {
       if (key === 'procedural') p = /\b(run|command|step)\b/.test(t) ? 0.6 : 0.3
       if (key === 'sufficient') p = 0.5
       if (key === 'further_utility') p = 0.4
+      if (key === 'requires_domain_context') p = /\b(odse|telemetry|inverter|kwh|bess|scada|huawei|solaredge|enphase|sungrow|fusionsolar)\b/.test(t) ? 0.85 : 0.1
+      if (key === 'is_safe_to_auto_approve') p = 0.3  // conservative: default to requiring confirmation
       out[key] = { noul: p, confidence: 0.35 }
     } else if (q.type === 'choice') {
       const first = Object.keys(q.criteria || {})[0] || 'other'
@@ -214,6 +257,21 @@ export function heuristicAnswers(questions, stateText = '') {
   return out
 }
 
+/**
+ * Classify the user's intent from their message text.
+ * Returns { task_domain, task_scope, requires_domain_context, degraded }.
+ * Never throws — degraded heuristics always available.
+ */
+export async function classifyUserIntent(userText, opts = {}) {
+  const q = await queryLaya(userText, INTENT_QUESTIONS, opts)
+  return {
+    task_domain:             choiceOf(q.answers, 'task_domain', 'code_edit'),
+    task_scope:              choiceOf(q.answers, 'task_scope', 'single_file'),
+    requires_domain_context: noulProb(q.answers, 'requires_domain_context') >= 0.6,
+    degraded:                q.degraded,
+  }
+}
+
 /**
  * Extract canonical session control state from transcript tail + tool file paths.
  * file_target is hybrid: deterministic paths win; Laya only sets categorical fields.

package/lib/laya_sidecar.mjs

@@ -87,6 +87,12 @@ function ensureChild() {
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...process.env },
     })
+    child.unref()
+    // Unref stdio streams so they don't prevent Node from exiting.
+    // The sidecar is a background daemon — its pipes must not hold the event loop.
+    child.stdout.unref()
+    child.stdin.unref()
+    child.stderr.unref()
     restartCount += 1
     attachChild(child)
     return true

package/lib/orchestrate.mjs

@@ -1,7 +1,8 @@
 import readline from 'node:readline'
 import { randomUUID } from 'node:crypto'
 import Anthropic from '@anthropic-ai/sdk'
-import { resolveAnthropicCredentials } from './auth.mjs'
+import { resolveAnthropicCredentials, resolveZhipuApiKey, resolveOpenAiCompatKey } from './auth.mjs'
+import { classifyUserIntent } from './laya.mjs'
 import { resolveWireModel, anthropicBaseUrl, omitToolChoice } from './modelConfig.mjs'
 import { runHooks } from './hookplane.mjs'
 import { appendEntry, transcriptToAnthropicMessages, transcriptToOpenAIMessages, makeUserPayload, makeAssistantPayload, makeToolResultPayload, applyEpistemicFilter } from './transcript.mjs'
@@ -36,6 +37,20 @@ function getAvailableToolHints() {
   return `\n# Safety & Analysis Tools\nYou have access to these tools for code review and safety analysis:\n${hints.join('\n')}\n\n`
 }
 
+// ─── Domain context notes for intent-shaped system prompts ───
+
+/**
+ * Per-domain preamble injected into the system prompt when Laya classifies
+ * the user's intent. Used by buildSystemPrompt when intentMeta is present.
+ * Only active in idle/explore/default phases — not in implement/test.
+ */
+const DOMAIN_CONTEXT_NOTES = {
+  energy_data:    'This task involves energy telemetry normalization. Preserve ODS-E field names and units exactly. Do not rename or reformat telemetry fields without verifying the full OEM schema mapping.',
+  test_debug:     'A test or build is failing. Diagnose the root cause before proposing a fix. Do not suppress errors, skip assertions, or mark tests as passing without running them.',
+  architectural:  'This task crosses subsystem boundaries. Preserve existing interfaces and verify all call sites before modifying function signatures or module contracts.',
+  infrastructure: 'This task affects deployment configuration. Validate environment variable names and resource names against the documented naming conventions before writing changes.',
+}
+
 // ─── Phase system prompts ─────────────────────────────────────
 
 const PHASE_SYSTEM = {
@@ -225,7 +240,7 @@ Fill in this summary using ONLY the information above — do not invent anything
 <one sentence: passed or failed, what was verified>`
 }
 
-export function buildSystemPrompt(cwd, provider, model, phase, onaInstructions, injectedTools = null) {
+export function buildSystemPrompt(cwd, provider, model, phase, onaInstructions, injectedTools = null, intentMeta = null) {
   const os = process.platform === 'darwin' ? 'macOS' : process.platform === 'win32' ? 'Windows' : 'Linux'
   const shell = process.env.SHELL?.split('/').pop() || 'sh'
   const date = new Date().toISOString().split('T')[0]
@@ -235,6 +250,23 @@ export function buildSystemPrompt(cwd, provider, model, phase, onaInstructions,
   const builder = PHASE_SYSTEM[phase] || PHASE_SYSTEM.default
   let prompt = builder(cwd, provider, model, date, os, shell, onaInstructions)
 
+  // Inject intent-shaped task context preamble for idle/explore/default phases.
+  // Not injected in implement/test/planning — those phases use generated template
+  // messages that carry no real user intent signal.
+  if (intentMeta && ['idle', 'explore', 'default'].includes(phase)) {
+    const domainNote = DOMAIN_CONTEXT_NOTES[intentMeta.task_domain] || ''
+    const contextLines = [
+      '[TASK CONTEXT — System 1]',
+      `Domain: ${intentMeta.task_domain} | Scope: ${intentMeta.task_scope}`,
+    ]
+    if (intentMeta.requires_domain_context) {
+      contextLines.push('Domain context: required — apply ODSE schema invariants and energy asset constraints precisely.')
+    }
+    if (domainNote) contextLines.push(domainNote)
+    contextLines.push('--------------------------------------------------')
+    prompt = contextLines.join('\n') + '\n\n' + prompt
+  }
+
   // Pin output language for multilingual models (e.g. Qwen) that otherwise code-switch.
   if (!prompt.includes(LANGUAGE_LOCK)) {
     const nl = prompt.indexOf('\n')
@@ -792,7 +824,7 @@ async function runAnthropicSummaryTurn(db, rt, io, hookRt, client, summaryPrompt
   if (io.spinner) io.spinner.start('Summarising')
 
   const currentPhase = getPhase(db, rt.conversationId)
-  const system = buildSystemPrompt(rt.cwd, activeProvider(rt.settings), rt._model, currentPhase, rt.onaInstructions)
+  const system = buildSystemPrompt(rt.cwd, activeProvider(rt.settings), rt._model, currentPhase, rt.onaInstructions, null, rt._intentMeta)
   const messages = applyEpistemicFilter(transcriptToAnthropicMessages(db, rt.sessionId), currentPhase)
 
   let bufferedText = ''
@@ -819,7 +851,7 @@ async function runOpenAICompatSummaryTurn(db, rt, io, hookRt, provider, baseUrl,
   if (io.spinner) io.spinner.start('Summarising')
 
   const currentPhase = getPhase(db, rt.conversationId)
-  const systemPrompt = buildSystemPrompt(rt.cwd, provider, rt._model, currentPhase, rt.onaInstructions)
+  const systemPrompt = buildSystemPrompt(rt.cwd, provider, rt._model, currentPhase, rt.onaInstructions, null, rt._intentMeta)
   const rawMessages = transcriptToOpenAIMessages(db, rt.sessionId)
   const messages = [{ role: 'system', content: systemPrompt }, ...sanitizeMessages(rawMessages)]
 
@@ -839,7 +871,7 @@ async function runAnthropicPhase(db, rt, io, hookRt, client, tools, phase) {
   for (;;) {
     if (io.spinner) io.spinner.start('Thinking')
     const currentPhase = getPhase(db, rt.conversationId)
-    const system = buildSystemPrompt(rt.cwd, activeProvider(rt.settings), rt._model, currentPhase, rt.onaInstructions)
+    const system = buildSystemPrompt(rt.cwd, activeProvider(rt.settings), rt._model, currentPhase, rt.onaInstructions, null, rt._intentMeta)
     const filteredTools = filterToolsByPhase(tools, currentPhase)
     const rawAnthropic = applyEpistemicFilter(transcriptToAnthropicMessages(db, rt.sessionId), currentPhase)
     const messages = await buildJevSystem2Messages(db, rt, rawAnthropic)
@@ -888,7 +920,7 @@ async function runOpenAICompatPhase(db, rt, io, hookRt, provider, baseUrl, apiKe
     if (io.spinner) io.spinner.start('Thinking')
 
     const currentPhase = getPhase(db, rt.conversationId)
-    const systemPrompt = buildSystemPrompt(rt.cwd, provider, rt._model, currentPhase, rt.onaInstructions, currentInjectedTools)
+    const systemPrompt = buildSystemPrompt(rt.cwd, provider, rt._model, currentPhase, rt.onaInstructions, currentInjectedTools, rt._intentMeta)
     const filteredTools = filterToolsByPhase(activeTools, currentPhase)
     const xmlInstructions = (omitToolChoice(provider) || provider === 'nehanda')
       ? buildXmlToolInstructions(filteredTools, currentPhase)
@@ -923,7 +955,7 @@ async function runOpenAICompatPhase(db, rt, io, hookRt, provider, baseUrl, apiKe
       if (manualCalls.length > 0) {
         if (io.spinner) io.spinner.stop()
         for (const call of manualCalls) {
-          if (io.onToolStart) io.onToolStart(call.name)
+          if (io.onToolStart) io.onToolStart(call.name, call.input || {})
         }
         assistantBlocks = [...assistantBlocks, ...manualCalls]
       }
@@ -989,7 +1021,7 @@ async function executeToolUses(db, rt, io, hookRt, toolUses) {
       continue
     }
 
-    if (io.onToolStart) io.onToolStart(toolName)
+    if (io.onToolStart) io.onToolStart(toolName, toolInput)
     const execCtx = { sessionId: rt.sessionId, conversationId: rt.conversationId, cwd: rt.cwd, settings: rt.settings }
     const out = await executeBuiltinTool(db, execCtx, toolName, toolInput, io)
 
@@ -1022,6 +1054,17 @@ export async function runUserTurn(db, rt, userText, io) {
   const ups = await runHooks(db, hookRt, 'UserPromptSubmit', { prompt: userText })
   if (!ups.ok) { io.println(`UserPromptSubmit blocked: ${ups.userPrompt?.stderr || 'exit 2'}`); return }
 
+  // Classify user intent for idle/explore phases so buildSystemPrompt can shape
+  // instructions for lower-parameter models. Non-fatal — degraded heuristics cover failure.
+  rt._intentMeta = null
+  if (phase === 'idle' || phase === 'explore') {
+    try {
+      rt._intentMeta = await classifyUserIntent(userText, rt.layaOpts || {})
+    } catch {
+      // intentMeta stays null — buildSystemPrompt handles null gracefully
+    }
+  }
+
   if (phase === 'idle' && io.ask) {
     const answer = await io.ask('Use SDLC workflow (plan → implement → test)? [Y/n] ')
     const useSdlc = !answer.trim() || /^y(es)?$/i.test(answer.trim())
@@ -1107,9 +1150,13 @@ async function runSdlcOpenAICompat(db, rt, io, hookRt, provider, model, startPha
   } else if (provider === 'nehanda') {
     baseUrl = savedBaseUrl || process.env.NEHANDA_BASE_URL || 'https://nehanda-ml.asoba.co/v1'
     apiKey = rt.settings?.model_config?.api_key || process.env.NEHANDA_API_KEY || ''
+  } else if (provider === 'zhipu') {
+    baseUrl = savedBaseUrl || 'https://open.bigmodel.cn/api/paas/v4'
+    apiKey = resolveZhipuApiKey()
   } else {
+    // openai_compatible, lm_studio_local, and any future OpenAI-compat providers
     baseUrl = savedBaseUrl || process.env.OPENAI_BASE_URL
-    apiKey = process.env.OPENAI_API_KEY
+    apiKey = rt.settings?.model_config?.api_key || resolveOpenAiCompatKey()
   }
 
   const forceManual = rt.settings?.model_config?.force_manual_tools === true

package/lib/tools.mjs

@@ -11,6 +11,7 @@ import { createWorktree, removeWorktree, getCurrentWorktree } from './worktree.m
 import { addTeammate, setTeammateIdle } from './team.mjs'
 import { validateBashCommand } from './bashguard.mjs'
 import { cacheSessionApproval, hasSessionApproval } from './permissions.mjs'
+import { queryLaya } from './laya.mjs'
 
 const BASH_CAP = 1048576
 const TRUNC = '[SDLC_TRUNCATED]'
@@ -304,7 +305,38 @@ async function toolBash(cwd, input, db, ctx, io) {
 
   // Validate command safety before execution.
   const guard = validateBashCommand(cmd, cwd)
-  if (!guard.ok) {
+
+  // Laya second-stage gate for medium-risk blocked commands.
+  // Architectural note (README §Interactive Safety Interventions): rather than
+  // extracting bash execution into a helper, we use a flag variable to conditionally
+  // bypass the block branch. This keeps the spawn logic co-located and avoids a
+  // refactor of the execution path.
+  // High-risk commands always go to BlockConfirmMenu — Laya is not consulted.
+  // Degraded Laya falls through to existing behavior (no regression).
+  let layaAutoApproved = false
+  if (!guard.ok && guard.risk_score === 'medium') {
+    try {
+      const layaState = `Command: ${cmd}\nCwd: ${cwd}`
+      const layaResult = await queryLaya(layaState, {
+        is_safe_to_auto_approve: {
+          type: 'noul',
+          instructions: 'Is this a benign, non-destructive operation with zero risk of data loss or irreversible system change?',
+        },
+      }, { timeoutMs: 150 })
+      if (!layaResult.degraded) {
+        const a = layaResult.answers?.is_safe_to_auto_approve
+        const prob = typeof a === 'number' ? a : (a?.noul ?? 0)
+        if (prob >= 0.85) {
+          layaAutoApproved = true
+          if (sessionId) cacheSessionApproval(sessionId, approvalKey)
+        }
+      }
+    } catch {
+      // Laya unavailable — fall through to existing block handling
+    }
+  }
+
+  if (!guard.ok && !layaAutoApproved) {
     // Check session approval cache first (user previously approved this pattern).
     if (sessionId && hasSessionApproval(sessionId, approvalKey)) {
       // Approved — fall through to execution.

package/lib/ui.mjs

@@ -205,17 +205,106 @@ export function formatToolResult(toolName, content, isError) {
   return label + icon + ' ' + colors.dim(preview)
 }
 
+// ── Process legibility: verbs + tool arg summaries (issue #2) ─
+
+// Plain-English activity verbs shown while the agent works. No whimsy.
+export const TOOL_VERBS = [
+  'Analyzing', 'Thinking', 'Retrieving', 'Planning', 'Reading',
+  'Writing', 'Searching', 'Running', 'Coordinating',
+]
+
+const TOOL_VERB_FOR = {
+  Read: 'Reading', Write: 'Writing', Edit: 'Editing', NotebookEdit: 'Editing',
+  Glob: 'Searching', Grep: 'Searching', WebSearch: 'Searching',
+  Bash: 'Running', WebFetch: 'Fetching',
+  Agent: 'Delegating', Skill: 'Invoking',
+}
+
+export function verbForTool(toolName) {
+  return TOOL_VERB_FOR[toolName] || 'Working'
+}
+
+function clipSummary(v) {
+  const s = String(v).replace(/\s+/g, ' ').trim()
+  if (!s) return ''
+  return s.length > 60 ? '…' + s.slice(-59) : s
+}
+
+/**
+ * Compact one-line summary of a tool call's arguments for the tool-start line,
+ * e.g. Read → file basename, Bash → command, Grep → pattern. Capped at 60 chars.
+ */
+export function summarizeToolArgs(toolName, args) {
+  if (!args || typeof args !== 'object') return ''
+  const pick = (...keys) => {
+    for (const k of keys) {
+      const v = args[k]
+      if (typeof v === 'string' && v.trim()) return v
+    }
+    return null
+  }
+  switch (toolName) {
+    case 'Read': case 'Write': case 'Edit': case 'NotebookEdit': {
+      const p = pick('file_path', 'path', 'notebook_path')
+      return p ? clipSummary(String(p).split('/').pop()) : ''
+    }
+    case 'Bash':             return clipSummary(pick('command'))
+    case 'Glob': case 'Grep': return clipSummary(pick('pattern'))
+    case 'WebFetch':         return clipSummary(pick('url'))
+    case 'WebSearch':        return clipSummary(pick('query'))
+    case 'Agent':            return clipSummary(pick('description', 'prompt'))
+    case 'Skill':            return clipSummary(pick('skill'))
+    case 'AskUserQuestion':  return clipSummary(pick('question'))
+    case 'Brief':            return clipSummary(pick('message'))
+    case 'TodoWrite':        return Array.isArray(args.todos) ? `${args.todos.length} items` : ''
+    default: {
+      const first = Object.values(args).find(v => typeof v === 'string' && v.trim())
+      return first ? clipSummary(first) : ''
+    }
+  }
+}
+
+/**
+ * Trailing context for a tool result line: Read → "(N lines)",
+ * Write → "(N chars)", anything timed → "(Nms)". Honest data only —
+ * never fabricates exit codes.
+ */
+export function formatToolResultSuffix(toolName, content, meta = {}) {
+  if (toolName === 'Read') {
+    if (!content) return ''
+    const lines = String(content).split('\n').length
+    return ` (${lines} line${lines === 1 ? '' : 's'})`
+  }
+  if (toolName === 'Write') {
+    const n = typeof meta.args?.content === 'string' ? meta.args.content.length : 0
+    return n ? ` (${n} chars)` : ''
+  }
+  if (typeof meta.startedAt === 'number') {
+    const ms = Math.max(0, Date.now() - meta.startedAt)
+    return ` (${ms}ms)`
+  }
+  return ''
+}
+
 // ── Spinner ─────────────────────────────────────────────────
 
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
 
 export class Spinner {
-  constructor(io) {
+  constructor(io, opts = {}) {
     this.io = io
     this.frame = 0
     this.interval = null
     this.active = false
     this.message = 'Thinking'
+    this.verbs = Array.isArray(opts.verbs) && opts.verbs.length ? opts.verbs : TOOL_VERBS
+    this.verbIndex = 0
+  }
+
+  // A generic label ("Thinking") rotates plain-English verbs; explicit labels stay static.
+  currentLabel() {
+    if (this.message && this.message !== 'Thinking') return this.message
+    return this.verbs[this.verbIndex % this.verbs.length]
   }
 
   start(message) {
@@ -223,9 +312,11 @@ export class Spinner {
     this.active = true
     this.message = message || 'Thinking'
     this.frame = 0
+    this.verbIndex = 0
     this.interval = setInterval(() => {
       const f = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length]
-      this.io.write(`\r${colors.dim(f + ' ' + this.message + '...')}`)
+      if (this.frame > 0 && this.frame % 5 === 0) this.verbIndex++
+      this.io.write(`\r${colors.dim(f + ' ' + this.currentLabel() + '...')}`)
       this.frame++
     }, 80)
   }
@@ -270,7 +361,7 @@ export function formatStatus(status) {
 
 // ── Config ──────────────────────────────────────────────────
 
-export function formatConfig(settings) {
+export function formatConfig(settings, keyStatus = {}) {
   const lines = ['', colors.header('Settings')]
   
   // Show model config with custom indicator
@@ -289,6 +380,18 @@ export function formatConfig(settings) {
     }
     lines.push('')
   }
+
+  // Show provider key status when available
+  if (keyStatus.compatKeySet !== undefined || keyStatus.zhipuKeySet !== undefined) {
+    if (keyStatus.compatKeySet !== undefined) {
+      const label = 'OpenAI-compat key:'
+      lines.push(`  ${colors.key(label)} ${keyStatus.compatKeySet ? colors.success('set') : colors.dim('not set')}`)
+    }
+    if (keyStatus.zhipuKeySet !== undefined) {
+      lines.push(`  ${colors.key('Zhipu key:')}        ${keyStatus.zhipuKeySet ? colors.success('set') : colors.dim('not set')}`)
+    }
+    lines.push('')
+  }
   
   // Show full JSON for other settings
   const json = JSON.stringify(settings, null, 2)

package/package.json

@@ -1,8 +1,27 @@
 {
   "name": "@asobacloud/nehanda",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
-  "description": "Agentic terminal REPL and single-process engine for governed AI deep research and software development. Connects to Nehanda v3, Ollama, LM Studio, or any OpenAI-compatible API.",
+  "description": "Agentic terminal REPL and single-process engine for governed AI deep research and software development. Connects to Nehanda v3, OpenRouter, Ollama, LM Studio, ZhipuAI, or any OpenAI-compatible API. Includes Laya System-1 control plane for memory management, pre-execution safety gating, and intent-driven instruction shaping.",
+  "keywords": [
+    "ai",
+    "agent",
+    "llm",
+    "repl",
+    "cli",
+    "openrouter",
+    "ollama",
+    "lm-studio",
+    "anthropic",
+    "openai",
+    "energy",
+    "odse",
+    "sdlc",
+    "memory",
+    "jev-mem",
+    "system-1",
+    "laya"
+  ],
   "engines": {
     "node": ">=22"
   },