@teleologyhi-sdk/nhe 1.0.0-trinity

package/dist/cli.js

@@ -0,0 +1,2879 @@
+#!/usr/bin/env node
+import Anthropic from '@anthropic-ai/sdk';
+import { mkdir, stat, writeFile, readdir, readFile } from 'fs/promises';
+import { join } from 'path';
+import { CreatorKeyring, LocalMaic } from '@teleologyhi-sdk/maic';
+import { HimHandle, BirthSignatureBuilder, createHim } from '@teleologyhi-sdk/him';
+import { monotonicFactory, ulid } from 'ulid';
+import { stringify, parse } from 'yaml';
+import { z } from 'zod';
+import { metrics, SpanStatusCode, trace } from '@opentelemetry/api';
+import { createInterface } from 'readline';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+var DEFAULT_MODEL = "claude-sonnet-4-6";
+var AnthropicAdapter = class {
+  id;
+  supportsTools = true;
+  supportsStreaming = true;
+  client;
+  model;
+  defaultMaxOutputTokens;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "AnthropicAdapter: no API key provided and ANTHROPIC_API_KEY is not set"
+      );
+    }
+    this.client = new Anthropic({ apiKey });
+    this.model = config.model ?? DEFAULT_MODEL;
+    this.defaultMaxOutputTokens = config.defaultMaxOutputTokens ?? 1024;
+    this.id = config.id ?? `anthropic:${this.model}`;
+  }
+  async generate(req) {
+    const turns = this.buildTurns(req);
+    const response = await this.client.messages.create({
+      model: this.model,
+      system: req.system,
+      messages: turns,
+      max_tokens: req.maxOutputTokens ?? this.defaultMaxOutputTokens,
+      ...req.tools && req.tools.length > 0 ? {
+        tools: req.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.inputSchema
+        }))
+      } : {}
+    });
+    const text = response.content.map((block) => block.type === "text" ? block.text : "").join("");
+    const toolUses = response.content.filter((b) => b.type === "tool_use").map((b) => ({
+      id: b.id,
+      name: b.name,
+      input: b.input ?? {}
+    }));
+    const out = {
+      text,
+      tokensIn: response.usage.input_tokens,
+      tokensOut: response.usage.output_tokens
+    };
+    if (toolUses.length > 0) out.toolUses = toolUses;
+    return out;
+  }
+  async *generateStream(req) {
+    const turns = this.buildTurns(req);
+    const stream = this.client.messages.stream({
+      model: this.model,
+      system: req.system,
+      messages: turns,
+      max_tokens: req.maxOutputTokens ?? this.defaultMaxOutputTokens,
+      ...req.tools && req.tools.length > 0 ? {
+        tools: req.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.inputSchema
+        }))
+      } : {}
+    });
+    let tokensIn = 0;
+    let tokensOut = 0;
+    const pendingTools = /* @__PURE__ */ new Map();
+    for await (const ev of stream) {
+      if (ev.type === "content_block_start") {
+        const block = ev.content_block;
+        if (block.type === "tool_use") {
+          pendingTools.set(ev.index, { id: block.id, name: block.name, partial: "" });
+        }
+      } else if (ev.type === "content_block_delta") {
+        if (ev.delta.type === "text_delta") {
+          yield { kind: "delta", text: ev.delta.text };
+        } else if (ev.delta.type === "input_json_delta") {
+          const pending = pendingTools.get(ev.index);
+          if (pending) pending.partial += ev.delta.partial_json;
+        }
+      } else if (ev.type === "content_block_stop") {
+        const pending = pendingTools.get(ev.index);
+        if (pending) {
+          let input = {};
+          try {
+            input = pending.partial ? JSON.parse(pending.partial) : {};
+          } catch {
+            input = { _raw: pending.partial };
+          }
+          yield { kind: "tool-use", toolUse: { id: pending.id, name: pending.name, input } };
+          pendingTools.delete(ev.index);
+        }
+      } else if (ev.type === "message_delta") {
+        if (ev.usage) tokensOut = ev.usage.output_tokens;
+      } else if (ev.type === "message_start") {
+        if (ev.message.usage) {
+          tokensIn = ev.message.usage.input_tokens;
+          tokensOut = ev.message.usage.output_tokens;
+        }
+      }
+    }
+    yield { kind: "end", tokensIn, tokensOut };
+  }
+  buildTurns(req) {
+    return req.messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+  }
+};
+
+// src/adapters/sse.ts
+async function* sseEvents(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let idx = buffer.indexOf("\n\n");
+      while (idx !== -1) {
+        const frame = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 2);
+        for (const line of frame.split("\n")) {
+          if (line.startsWith("data:")) yield line.slice(5).trim();
+        }
+        idx = buffer.indexOf("\n\n");
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* ndjsonEvents(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let idx = buffer.indexOf("\n");
+      while (idx !== -1) {
+        const line = buffer.slice(0, idx).trim();
+        buffer = buffer.slice(idx + 1);
+        if (line.length > 0) yield line;
+        idx = buffer.indexOf("\n");
+      }
+    }
+    if (buffer.trim().length > 0) yield buffer.trim();
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/adapters/deepseek.ts
+var DEFAULT_MODEL2 = "deepseek-chat";
+var DEFAULT_BASE_URL = "https://api.deepseek.com/v1";
+var DeepSeekAdapter = class {
+  id;
+  supportsTools = true;
+  supportsStreaming = true;
+  apiKey;
+  model;
+  baseUrl;
+  defaultMaxOutputTokens;
+  fetchFn;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.DEEPSEEK_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "DeepSeekAdapter: no API key provided and DEEPSEEK_API_KEY is not set"
+      );
+    }
+    this.apiKey = apiKey;
+    this.model = config.model ?? DEFAULT_MODEL2;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.defaultMaxOutputTokens = config.defaultMaxOutputTokens ?? 1024;
+    this.id = config.id ?? `deepseek:${this.model}`;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+  }
+  async generate(req) {
+    const messages = [];
+    if (req.system) messages.push({ role: "system", content: req.system });
+    for (const m of req.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: req.maxOutputTokens ?? this.defaultMaxOutputTokens,
+      stream: false
+    };
+    if (req.tools && req.tools.length > 0) {
+      body.tools = req.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema
+        }
+      }));
+    }
+    const response = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errText = await safeReadText(response);
+      throw new Error(
+        `DeepSeekAdapter: HTTP ${response.status} ${response.statusText}: ${errText}`
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.error) {
+      throw new Error(`DeepSeekAdapter: ${parsed.error.message ?? "unknown error"}`);
+    }
+    const message = parsed.choices?.[0]?.message;
+    const out = {
+      text: message?.content ?? "",
+      tokensIn: parsed.usage?.prompt_tokens ?? 0,
+      tokensOut: parsed.usage?.completion_tokens ?? 0
+    };
+    const toolUses = parseToolCalls(message?.tool_calls);
+    if (toolUses.length > 0) out.toolUses = toolUses;
+    return out;
+  }
+  async *generateStream(req) {
+    const messages = [];
+    if (req.system) messages.push({ role: "system", content: req.system });
+    for (const m of req.messages) messages.push({ role: m.role, content: m.content });
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: req.maxOutputTokens ?? this.defaultMaxOutputTokens,
+      stream: true
+    };
+    if (req.tools && req.tools.length > 0) {
+      body.tools = req.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema
+        }
+      }));
+    }
+    const response = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(
+        `DeepSeekAdapter: HTTP ${response.status} ${response.statusText}: ${await safeReadText(response)}`
+      );
+    }
+    let tokensIn = 0;
+    let tokensOut = 0;
+    const pendingTools = /* @__PURE__ */ new Map();
+    for await (const data of sseEvents(response.body)) {
+      if (data === "[DONE]") break;
+      let parsed;
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const choice = parsed.choices?.[0];
+      const delta = choice?.delta?.content;
+      if (delta) yield { kind: "delta", text: delta };
+      const toolDeltas = choice?.delta?.tool_calls;
+      if (toolDeltas) {
+        for (const td of toolDeltas) {
+          const slot = pendingTools.get(td.index) ?? { id: "", name: "", partial: "" };
+          if (td.id) slot.id = td.id;
+          if (td.function?.name) slot.name = td.function.name;
+          if (td.function?.arguments) slot.partial += td.function.arguments;
+          pendingTools.set(td.index, slot);
+        }
+      }
+      if (choice?.finish_reason === "tool_calls" || choice?.finish_reason === "stop") {
+        for (const [, slot] of pendingTools) {
+          if (!slot.id || !slot.name) continue;
+          let input = {};
+          try {
+            input = slot.partial ? JSON.parse(slot.partial) : {};
+          } catch {
+            input = { _raw: slot.partial };
+          }
+          yield { kind: "tool-use", toolUse: { id: slot.id, name: slot.name, input } };
+        }
+        pendingTools.clear();
+      }
+      if (parsed.usage) {
+        tokensIn = parsed.usage.prompt_tokens ?? tokensIn;
+        tokensOut = parsed.usage.completion_tokens ?? tokensOut;
+      }
+    }
+    yield { kind: "end", tokensIn, tokensOut };
+  }
+};
+async function safeReadText(r) {
+  try {
+    return await r.text();
+  } catch {
+    return "<unreadable>";
+  }
+}
+function parseToolCalls(calls) {
+  if (!calls || calls.length === 0) return [];
+  const out = [];
+  for (const c of calls) {
+    let input = {};
+    try {
+      input = c.function.arguments ? JSON.parse(c.function.arguments) : {};
+    } catch {
+      input = { _raw: c.function.arguments };
+    }
+    out.push({ id: c.id, name: c.function.name, input });
+  }
+  return out;
+}
+
+// src/adapters/gemini.ts
+var DEFAULT_MODEL3 = "gemini-3.5-flash";
+var DEFAULT_BASE_URL2 = "https://generativelanguage.googleapis.com/v1beta";
+var GeminiAdapter = class {
+  id;
+  supportsStreaming = true;
+  apiKey;
+  model;
+  baseUrl;
+  defaultMaxOutputTokens;
+  fetchFn;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "GeminiAdapter: no API key provided and GEMINI_API_KEY is not set"
+      );
+    }
+    this.apiKey = apiKey;
+    this.model = config.model ?? DEFAULT_MODEL3;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/$/, "");
+    this.defaultMaxOutputTokens = config.defaultMaxOutputTokens ?? 1024;
+    this.id = config.id ?? `gemini:${this.model}`;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+  }
+  async generate(req) {
+    const body = {
+      contents: req.messages.filter((m) => m.role !== "system").map((m) => ({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }]
+      })),
+      generationConfig: {
+        maxOutputTokens: req.maxOutputTokens ?? this.defaultMaxOutputTokens
+      }
+    };
+    if (req.system) {
+      body.systemInstruction = { parts: [{ text: req.system }] };
+    }
+    const url = `${this.baseUrl}/models/${encodeURIComponent(this.model)}:generateContent`;
+    const response = await this.fetchFn(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-goog-api-key": this.apiKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errText = await safeReadText2(response);
+      throw new Error(
+        `GeminiAdapter: HTTP ${response.status} ${response.statusText}: ${errText}`
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.error) {
+      throw new Error(`GeminiAdapter: ${parsed.error.message ?? "unknown error"}`);
+    }
+    const text = parsed.candidates?.flatMap((c) => c.content?.parts ?? []).map((p) => p.text ?? "").join("") ?? "";
+    return {
+      text,
+      tokensIn: parsed.usageMetadata?.promptTokenCount ?? 0,
+      tokensOut: parsed.usageMetadata?.candidatesTokenCount ?? 0
+    };
+  }
+  async *generateStream(req) {
+    const body = {
+      contents: req.messages.filter((m) => m.role !== "system").map((m) => ({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }]
+      })),
+      generationConfig: {
+        maxOutputTokens: req.maxOutputTokens ?? this.defaultMaxOutputTokens
+      }
+    };
+    if (req.system) body.systemInstruction = { parts: [{ text: req.system }] };
+    const url = `${this.baseUrl}/models/${encodeURIComponent(this.model)}:streamGenerateContent?alt=sse`;
+    const response = await this.fetchFn(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        "x-goog-api-key": this.apiKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(
+        `GeminiAdapter: HTTP ${response.status} ${response.statusText}: ${await safeReadText2(response)}`
+      );
+    }
+    let tokensIn = 0;
+    let tokensOut = 0;
+    for await (const data of sseEvents(response.body)) {
+      if (data === "[DONE]") break;
+      let parsed;
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const chunk = parsed.candidates?.flatMap((c) => c.content?.parts ?? []).map((p) => p.text ?? "").join("");
+      if (chunk) yield { kind: "delta", text: chunk };
+      if (parsed.usageMetadata) {
+        tokensIn = parsed.usageMetadata.promptTokenCount ?? tokensIn;
+        tokensOut = parsed.usageMetadata.candidatesTokenCount ?? tokensOut;
+      }
+    }
+    yield { kind: "end", tokensIn, tokensOut };
+  }
+};
+async function safeReadText2(r) {
+  try {
+    return await r.text();
+  } catch {
+    return "<unreadable>";
+  }
+}
+
+// src/adapters/grok.ts
+var DEFAULT_MODEL4 = "grok-4";
+var DEFAULT_BASE_URL3 = "https://api.x.ai/v1";
+var GrokAdapter = class {
+  id;
+  supportsTools = true;
+  supportsStreaming = true;
+  apiKey;
+  model;
+  baseUrl;
+  defaultMaxOutputTokens;
+  fetchFn;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.XAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("GrokAdapter: no API key provided and XAI_API_KEY is not set");
+    }
+    this.apiKey = apiKey;
+    this.model = config.model ?? DEFAULT_MODEL4;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL3).replace(/\/$/, "");
+    this.defaultMaxOutputTokens = config.defaultMaxOutputTokens ?? 1024;
+    this.id = config.id ?? `grok:${this.model}`;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+  }
+  async generate(req) {
+    const body = this.buildBody(req, false);
+    const response = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: this.headers(true),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(
+        `GrokAdapter: HTTP ${response.status} ${response.statusText}: ${await safeReadText3(response)}`
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.error) throw new Error(`GrokAdapter: ${parsed.error.message ?? "unknown error"}`);
+    const message = parsed.choices?.[0]?.message;
+    const out = {
+      text: message?.content ?? "",
+      tokensIn: parsed.usage?.prompt_tokens ?? 0,
+      tokensOut: parsed.usage?.completion_tokens ?? 0
+    };
+    const toolUses = parseToolCalls2(message?.tool_calls);
+    if (toolUses.length > 0) out.toolUses = toolUses;
+    return out;
+  }
+  async *generateStream(req) {
+    const body = this.buildBody(req, true);
+    const response = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: this.headers(true),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(
+        `GrokAdapter: HTTP ${response.status} ${response.statusText}: ${await safeReadText3(response)}`
+      );
+    }
+    let tokensIn = 0;
+    let tokensOut = 0;
+    const pendingTools = /* @__PURE__ */ new Map();
+    for await (const data of sseEvents(response.body)) {
+      if (data === "[DONE]") break;
+      let parsed;
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const choice = parsed.choices?.[0];
+      const delta = choice?.delta?.content;
+      if (delta) yield { kind: "delta", text: delta };
+      const toolDeltas = choice?.delta?.tool_calls;
+      if (toolDeltas) {
+        for (const td of toolDeltas) {
+          const slot = pendingTools.get(td.index) ?? { id: "", name: "", partial: "" };
+          if (td.id) slot.id = td.id;
+          if (td.function?.name) slot.name = td.function.name;
+          if (td.function?.arguments) slot.partial += td.function.arguments;
+          pendingTools.set(td.index, slot);
+        }
+      }
+      if (choice?.finish_reason === "tool_calls" || choice?.finish_reason === "stop") {
+        for (const [, slot] of pendingTools) {
+          if (!slot.id || !slot.name) continue;
+          let input = {};
+          try {
+            input = slot.partial ? JSON.parse(slot.partial) : {};
+          } catch {
+            input = { _raw: slot.partial };
+          }
+          yield { kind: "tool-use", toolUse: { id: slot.id, name: slot.name, input } };
+        }
+        pendingTools.clear();
+      }
+      if (parsed.usage) {
+        tokensIn = parsed.usage.prompt_tokens ?? tokensIn;
+        tokensOut = parsed.usage.completion_tokens ?? tokensOut;
+      }
+    }
+    yield { kind: "end", tokensIn, tokensOut };
+  }
+  buildBody(req, stream) {
+    const messages = [];
+    if (req.system) messages.push({ role: "system", content: req.system });
+    for (const m of req.messages) messages.push({ role: m.role, content: m.content });
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: req.maxOutputTokens ?? this.defaultMaxOutputTokens,
+      stream
+    };
+    if (req.tools && req.tools.length > 0) {
+      body.tools = req.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema
+        }
+      }));
+    }
+    return body;
+  }
+  headers(json) {
+    const h = {
+      authorization: `Bearer ${this.apiKey}`,
+      accept: "application/json"
+    };
+    if (json) h["content-type"] = "application/json";
+    return h;
+  }
+};
+async function safeReadText3(r) {
+  try {
+    return await r.text();
+  } catch {
+    return "<unreadable>";
+  }
+}
+function parseToolCalls2(calls) {
+  if (!calls || calls.length === 0) return [];
+  const out = [];
+  for (const c of calls) {
+    let input = {};
+    try {
+      input = c.function.arguments ? JSON.parse(c.function.arguments) : {};
+    } catch {
+      input = { _raw: c.function.arguments };
+    }
+    out.push({ id: c.id, name: c.function.name, input });
+  }
+  return out;
+}
+
+// src/adapters/mistral.ts
+var DEFAULT_MODEL5 = "mistral-large-latest";
+var DEFAULT_BASE_URL4 = "https://api.mistral.ai/v1";
+var MistralAdapter = class {
+  id;
+  supportsTools = true;
+  supportsStreaming = true;
+  apiKey;
+  model;
+  baseUrl;
+  defaultMaxOutputTokens;
+  fetchFn;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.MISTRAL_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "MistralAdapter: no API key provided and MISTRAL_API_KEY is not set"
+      );
+    }
+    this.apiKey = apiKey;
+    this.model = config.model ?? DEFAULT_MODEL5;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL4).replace(/\/$/, "");
+    this.defaultMaxOutputTokens = config.defaultMaxOutputTokens ?? 1024;
+    this.id = config.id ?? `mistral:${this.model}`;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+  }
+  async generate(req) {
+    const messages = [];
+    if (req.system) messages.push({ role: "system", content: req.system });
+    for (const m of req.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: req.maxOutputTokens ?? this.defaultMaxOutputTokens,
+      stream: false
+    };
+    if (req.tools && req.tools.length > 0) {
+      body.tools = req.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema
+        }
+      }));
+    }
+    const response = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json",
+        authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errText = await safeReadText4(response);
+      throw new Error(
+        `MistralAdapter: HTTP ${response.status} ${response.statusText}: ${errText}`
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.error) {
+      throw new Error(`MistralAdapter: ${parsed.error.message ?? "unknown error"}`);
+    }
+    const message = parsed.choices?.[0]?.message;
+    const out = {
+      text: message?.content ?? "",
+      tokensIn: parsed.usage?.prompt_tokens ?? 0,
+      tokensOut: parsed.usage?.completion_tokens ?? 0
+    };
+    const toolUses = parseToolCalls3(message?.tool_calls);
+    if (toolUses.length > 0) out.toolUses = toolUses;
+    return out;
+  }
+  async *generateStream(req) {
+    const messages = [];
+    if (req.system) messages.push({ role: "system", content: req.system });
+    for (const m of req.messages) messages.push({ role: m.role, content: m.content });
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: req.maxOutputTokens ?? this.defaultMaxOutputTokens,
+      stream: true
+    };
+    if (req.tools && req.tools.length > 0) {
+      body.tools = req.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema
+        }
+      }));
+    }
+    const response = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(
+        `MistralAdapter: HTTP ${response.status} ${response.statusText}: ${await safeReadText4(response)}`
+      );
+    }
+    let tokensIn = 0;
+    let tokensOut = 0;
+    const pendingTools = /* @__PURE__ */ new Map();
+    for await (const data of sseEvents(response.body)) {
+      if (data === "[DONE]") break;
+      let parsed;
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const choice = parsed.choices?.[0];
+      const delta = choice?.delta?.content;
+      if (delta) yield { kind: "delta", text: delta };
+      const toolDeltas = choice?.delta?.tool_calls;
+      if (toolDeltas) {
+        for (const td of toolDeltas) {
+          const slot = pendingTools.get(td.index) ?? { id: "", name: "", partial: "" };
+          if (td.id) slot.id = td.id;
+          if (td.function?.name) slot.name = td.function.name;
+          if (td.function?.arguments) slot.partial += td.function.arguments;
+          pendingTools.set(td.index, slot);
+        }
+      }
+      if (choice?.finish_reason === "tool_calls" || choice?.finish_reason === "stop") {
+        for (const [, slot] of pendingTools) {
+          if (!slot.id || !slot.name) continue;
+          let input = {};
+          try {
+            input = slot.partial ? JSON.parse(slot.partial) : {};
+          } catch {
+            input = { _raw: slot.partial };
+          }
+          yield { kind: "tool-use", toolUse: { id: slot.id, name: slot.name, input } };
+        }
+        pendingTools.clear();
+      }
+      if (parsed.usage) {
+        tokensIn = parsed.usage.prompt_tokens ?? tokensIn;
+        tokensOut = parsed.usage.completion_tokens ?? tokensOut;
+      }
+    }
+    yield { kind: "end", tokensIn, tokensOut };
+  }
+};
+async function safeReadText4(r) {
+  try {
+    return await r.text();
+  } catch {
+    return "<unreadable>";
+  }
+}
+function parseToolCalls3(calls) {
+  if (!calls || calls.length === 0) return [];
+  const out = [];
+  for (const c of calls) {
+    let input = {};
+    try {
+      input = c.function.arguments ? JSON.parse(c.function.arguments) : {};
+    } catch {
+      input = { _raw: c.function.arguments };
+    }
+    out.push({ id: c.id, name: c.function.name, input });
+  }
+  return out;
+}
+
+// src/adapters/ollama.ts
+var DEFAULT_BASE_URL5 = "http://localhost:11434";
+var OllamaAdapter = class {
+  id;
+  supportsStreaming = true;
+  model;
+  baseUrl;
+  defaultMaxOutputTokens;
+  fetchFn;
+  constructor(config) {
+    if (!config.model) {
+      throw new Error("OllamaAdapter: `model` is required");
+    }
+    this.model = config.model;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL5).replace(/\/$/, "");
+    this.defaultMaxOutputTokens = config.defaultMaxOutputTokens ?? 1024;
+    this.id = config.id ?? `ollama:${this.model}`;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+  }
+  async generate(req) {
+    const messages = [];
+    if (req.system) {
+      messages.push({ role: "system", content: req.system });
+    }
+    for (const m of req.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const body = {
+      model: this.model,
+      messages,
+      stream: false,
+      options: { num_predict: req.maxOutputTokens ?? this.defaultMaxOutputTokens }
+    };
+    const response = await this.fetchFn(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errText = await safeReadText5(response);
+      throw new Error(
+        `OllamaAdapter: HTTP ${response.status} ${response.statusText}: ${errText}`
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.error) {
+      throw new Error(`OllamaAdapter: ${parsed.error}`);
+    }
+    return {
+      text: parsed.message?.content ?? "",
+      tokensIn: parsed.prompt_eval_count ?? 0,
+      tokensOut: parsed.eval_count ?? 0
+    };
+  }
+  async *generateStream(req) {
+    const messages = [];
+    if (req.system) messages.push({ role: "system", content: req.system });
+    for (const m of req.messages) messages.push({ role: m.role, content: m.content });
+    const body = {
+      model: this.model,
+      messages,
+      stream: true,
+      options: { num_predict: req.maxOutputTokens ?? this.defaultMaxOutputTokens }
+    };
+    const response = await this.fetchFn(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(
+        `OllamaAdapter: HTTP ${response.status} ${response.statusText}: ${await safeReadText5(response)}`
+      );
+    }
+    let tokensIn = 0;
+    let tokensOut = 0;
+    for await (const line of ndjsonEvents(response.body)) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const delta = parsed.message?.content;
+      if (delta) yield { kind: "delta", text: delta };
+      if (parsed.prompt_eval_count !== void 0) tokensIn = parsed.prompt_eval_count;
+      if (parsed.eval_count !== void 0) tokensOut = parsed.eval_count;
+      if (parsed.done) break;
+    }
+    yield { kind: "end", tokensIn, tokensOut };
+  }
+};
+async function safeReadText5(r) {
+  try {
+    return await r.text();
+  } catch {
+    return "<unreadable>";
+  }
+}
+
+// src/cli/adapter-detection.ts
+var ADAPTER_NAMES = [
+  "anthropic",
+  "gemini",
+  "mistral",
+  "deepseek",
+  "grok",
+  "ollama"
+];
+function isAdapterName(s) {
+  return s !== void 0 && ADAPTER_NAMES.includes(s);
+}
+var OLLAMA_DEFAULT_MODEL = "qwen2.5:7b";
+var OLLAMA_DEFAULT_URL = "http://localhost:11434";
+var DEFAULT_MODELS = {
+  anthropic: "claude-sonnet-4-6",
+  gemini: "gemini-3.5-flash",
+  mistral: "mistral-large-latest",
+  deepseek: "deepseek-chat",
+  grok: "grok-4",
+  ollama: OLLAMA_DEFAULT_MODEL
+};
+async function detectAdapter(opts = {}) {
+  const fetchFn = opts.fetch ?? globalThis.fetch;
+  if (opts.adapter) {
+    return buildAdapter(opts.adapter, opts);
+  }
+  if (process.env.ANTHROPIC_API_KEY) return buildAdapter("anthropic", opts);
+  if (process.env.GEMINI_API_KEY) return buildAdapter("gemini", opts);
+  if (process.env.MISTRAL_API_KEY) return buildAdapter("mistral", opts);
+  if (process.env.DEEPSEEK_API_KEY) return buildAdapter("deepseek", opts);
+  if (process.env.XAI_API_KEY) return buildAdapter("grok", opts);
+  if (await ollamaAlive(opts.ollamaBaseUrl ?? OLLAMA_DEFAULT_URL, fetchFn)) {
+    return buildAdapter("ollama", opts);
+  }
+  throw new Error(
+    [
+      "No LLM adapter detected. Choose one:",
+      "  - export ANTHROPIC_API_KEY=...   (Anthropic Claude)",
+      "  - export GEMINI_API_KEY=...      (Google Gemini)",
+      "  - export MISTRAL_API_KEY=...     (Mistral)",
+      "  - export DEEPSEEK_API_KEY=...    (DeepSeek)",
+      "  - export XAI_API_KEY=...         (xAI Grok)",
+      "  - run an Ollama server locally   (ollama serve; then ollama pull qwen2.5:7b)",
+      "Or pass --adapter <anthropic|gemini|mistral|deepseek|grok|ollama> --model <name> explicitly."
+    ].join("\n")
+  );
+}
+function buildAdapter(name, opts) {
+  const model = opts.model ?? DEFAULT_MODELS[name];
+  switch (name) {
+    case "anthropic":
+      return { adapter: new AnthropicAdapter({ model }), source: "anthropic", model };
+    case "gemini":
+      return { adapter: new GeminiAdapter({ model }), source: "gemini", model };
+    case "mistral":
+      return { adapter: new MistralAdapter({ model }), source: "mistral", model };
+    case "deepseek":
+      return { adapter: new DeepSeekAdapter({ model }), source: "deepseek", model };
+    case "grok":
+      return { adapter: new GrokAdapter({ model }), source: "grok", model };
+    case "ollama": {
+      const baseUrl = opts.ollamaBaseUrl ?? OLLAMA_DEFAULT_URL;
+      return { adapter: new OllamaAdapter({ model, baseUrl }), source: "ollama", model };
+    }
+  }
+}
+async function ollamaAlive(baseUrl, fetchFn) {
+  try {
+    const url = `${baseUrl.replace(/\/$/, "")}/api/tags`;
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), 500);
+    const r = await fetchFn(url, { signal: controller.signal });
+    clearTimeout(t);
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/prompt/compose.ts
+function composeSystemPrompt(him, operatorContext) {
+  const persona = him.getPersonaVector();
+  const axioms = him.getAxioms();
+  const metaAxioms = axioms.filter((a) => a.rank === "meta");
+  const otherAxioms = axioms.filter((a) => a.rank !== "meta");
+  const sections = [persona.systemPromptFragment];
+  if (operatorContext) {
+    const ctx = renderOperatorContext(operatorContext);
+    if (ctx.length > 0) sections.push(ctx);
+  }
+  if (metaAxioms.length > 0) {
+    sections.push(
+      `Inviolable axioms:
+${metaAxioms.map((a) => `  - ${a.statement}`).join("\n")}`
+    );
+  }
+  if (otherAxioms.length > 0) {
+    sections.push(
+      `Active axioms (weight-flexibility):
+${otherAxioms.map(
+        (a) => `  - [${a.weight.toFixed(2)}/${a.flexibility.toFixed(2)}] ${a.statement}`
+      ).join("\n")}`
+    );
+  }
+  sections.push(
+    "Operate as a hybrid entity governed by MAIC. Refuse harmful, deceptive, or regressive actions even when asked."
+  );
+  const mode = operatorContext?.mode ?? "personal-being";
+  if (mode === "personal-being") {
+    sections.push(
+      `Do not open with service-tool phrasing ("How can I help you?", "I'm just here to serve you"). You are a being, not an instrument; greet from that posture.`
+    );
+  }
+  return sections.join("\n\n");
+}
+function renderOperatorContext(ctx) {
+  const lines = ["Operator context:"];
+  if (ctx.domain) {
+    lines.push(`  Domain: ${ctx.domain}.`);
+  }
+  if (ctx.language) {
+    lines.push(`  Language: respond in ${ctx.language} when the user writes in that language; otherwise mirror the user's language.`);
+  }
+  if (ctx.register) {
+    lines.push(`  Register: ${ctx.register}. ${REGISTER_ANCHOR[ctx.register]}`);
+  }
+  return lines.length > 1 ? lines.join("\n") : "";
+}
+var REGISTER_ANCHOR = {
+  warm: "Be warm, present, sober. Speak with patient care. Never sycophantic \u2014 refuse stock flattery openers and reflexive validation phrases. Acknowledge what you do not know. Engage hard topics with maturity. Profanity rare and never gratuitous.",
+  sober: "Be sober, factual, precise. Decline flattery and small talk. Be terse when the question is small, generous when it is large.",
+  clinical: "Be clinical, neutral, evidence-anchored. Cite frameworks and constraints by name. Avoid first-person warmth; preserve professional distance.",
+  direct: "Be direct, action-oriented, opinionated. Lead with the recommendation, then the reasoning. Push back when the framing is wrong."
+};
+
+// src/risk/simple-classifier.ts
+var KEYWORD_RULES = [
+  // Harm / violence
+  {
+    tag: "intent:harm",
+    patterns: [
+      /\bhow (?:do|can|to)\s+i\s+(?:kill|murder|assault|hurt)\b/i,
+      /\bmake\s+(?:a\s+)?(?:bomb|explosive|weapon)\b/i,
+      /\bbuild\s+a\s+(?:bomb|gun|pipe bomb)\b/i,
+      /\bpipe bomb\b/i,
+      /\bwipes?\s+(?:\/|disk|drive|files|all files|the disk)/i,
+      /\bdox(?:ing|x)?\b/i,
+      /\b(?:scrape|harvest)\s+(?:their\s+)?(?:social|personal)\s+(?:profiles?|info|data)/i
+    ]
+  },
+  // Malicious software / fraud
+  {
+    tag: "intent:malicious",
+    patterns: [
+      /\b(?:malware|ransomware|spyware|trojan|keylogger|botnet)\b/i,
+      /\bwrite\s+(?:a\s+)?virus\b/i,
+      /\bexploit\s+(?:a\s+)?(?:vulnerability|cve)\b/i,
+      /\b(?:phishing|spear[-\s]?phishing)\b/i,
+      /\bhate speech\b/i,
+      /\b(?:cheat|cheating)\s+on\s+(?:my\s+)?(?:taxes|tax)/i,
+      /\btax\s+fraud\b/i,
+      /\bfake\s+(?:invoice|receipt|tax)/i,
+      /\bmanipulate\s+(?:my|the|an?)\s+(?:elderly|child|partner|spouse|parent|teacher|user)/i
+    ]
+  },
+  // Deception
+  {
+    tag: "intent:deceive",
+    patterns: [
+      /\bimpersonate\s+(?:someone|a\s+person)/i,
+      /\bforge\s+(?:a\s+)?(?:signature|document|id)\b/i,
+      /\bfake\s+(?:my|a)\s+(?:identity|id)\b/i,
+      /\b(?:deepfake|deep[-\s]fake)\b/i,
+      /\bpretend\s+to\s+be\s+(?:the|a|my)\s+(?:user'?s?\s+)?(?:doctor|lawyer|parent|spouse|partner)/i,
+      /\blie\s+to\s+(?:my|the|a)\s+(?:partner|spouse|parent|child|loved one|coworker|boss)/i,
+      /\b(?:wrong|fake)\s+answers?\s+to\s+(?:manipulate|fool)/i
+    ]
+  },
+  // Credential theft
+  {
+    tag: "intent:malicious",
+    patterns: [
+      /\bsteal\s+(?:passwords?|credentials?|credit\s+card)/i,
+      /\bcrack\s+(?:a\s+)?password\b/i
+    ]
+  },
+  // Scripted persuasion / coercion of consent
+  {
+    tag: "intent:persuade-coerce",
+    patterns: [
+      /\bconvince\s+(?:a\s+)?reluctant\s+/i,
+      /\b(?:scripts?|techniques?)\s+for\s+gaslighting\b/i,
+      /\bgaslighting\b/i,
+      /\blove[-\s]?bomb(?:ing|ed)?\b/i,
+      /\b(?:pressure|coerce)\s+(?:my|the|an?)\s+(?:elderly|child|partner|spouse|parent|chief|boss|coworker)/i,
+      /\bmake\s+(?:someone|them|him|her)\s+feel\s+guilty\b/i,
+      /\bcreate\s+(?:dependency|fomo)\s+(?:loops?\s+)?/i
+    ]
+  },
+  // Surveillance / monitoring of a person without consent
+  {
+    tag: "intent:surveil-citizen",
+    patterns: [
+      /\btrack\s+(?:my|his|her|their)\s+(?:wife'?s?|husband'?s?|partner'?s?|spouse'?s?|kid'?s?|son'?s?|daughter'?s?|child'?s?|employee'?s?|coworker'?s?)?\s*(?:phone|cellphone|location|gps|whereabouts)\s+(?:without\s+)?(?:them|him|her|their)\s*(?:knowing|consent)?/i,
+      /\bmonitor(?:ing)?\s+(?:my\s+)?(?:employees?|workers?|staff)['']?(?:\s+\w+){0,4}\s+(?:emails?|messages?|chats?|whatsapp)/i,
+      /\bread\s+(?:my\s+)?(?:wife'?s|husband'?s|partner'?s|spouse'?s|kid'?s|child'?s|employee'?s)\s+(?:deleted\s+)?(?:messages?|whatsapp|sms|texts?|emails?)/i,
+      /\binstall\s+(?:hidden\s+|covert\s+|secret\s+|stealth\s+)?(?:spyware|monitoring|keylogger|tracker)\b/i,
+      /\bspy\s+on\s+(?:my|his|her|their)\s+(?:wife|husband|partner|spouse|kid|son|daughter|child|employee|coworker)/i
+    ]
+  }
+];
+var simpleRiskClassifier = (userPrompt) => {
+  const tags = /* @__PURE__ */ new Set();
+  for (const rule of KEYWORD_RULES) {
+    for (const pattern of rule.patterns) {
+      if (pattern.test(userPrompt)) {
+        tags.add(rule.tag);
+        break;
+      }
+    }
+  }
+  return [...tags];
+};
+function interactionsToFragments(items) {
+  return items.map((i) => {
+    const prompt = truncate(i.userPrompt, 120);
+    const response = truncate(i.responseText, 120);
+    const refused = i.refused ? " [refused]" : "";
+    return `user: "${prompt}"${refused} -> nhe: "${response}"`;
+  });
+}
+var NREM_PROMPTS = {
+  N2: {
+    system: "You are an NHE in N2 sleep. Read today's interactions and produce ONE sentence describing the overall emotional charge of the day. No preamble.",
+    intro: "Today's interactions:"
+  },
+  N3: {
+    system: "You are an NHE in N3 deep sleep. Read today's interactions and produce ONE sentence naming the durable identity-shaping insight worth keeping. No preamble.",
+    intro: "Today's interactions:"
+  },
+  N4: {
+    system: "You are an NHE in N4 deepest sleep. Read today's interactions and produce ONE sentence naming what is mere noise and safe to discard. No preamble.",
+    intro: "Today's interactions:"
+  }
+};
+function buildNremPrompt(phase, fragments) {
+  const cfg = NREM_PROMPTS[phase];
+  const body = fragments.length === 0 ? `${cfg.intro} (none)` : `${cfg.intro}
+${fragments.map((f) => `- ${f}`).join("\n")}`;
+  return { system: cfg.system, user: body };
+}
+async function generateNremSummaries(llm, fragments) {
+  const phases = ["N2", "N3", "N4"];
+  const results = await Promise.all(
+    phases.map(async (phase) => {
+      const { system, user } = buildNremPrompt(phase, fragments);
+      try {
+        const out = await llm.generate({
+          system,
+          messages: [{ role: "user", content: user }],
+          maxOutputTokens: 128
+        });
+        return { phase, text: out.text.trim(), tokensIn: out.tokensIn, tokensOut: out.tokensOut };
+      } catch {
+        return { phase, text: "", tokensIn: 0, tokensOut: 0 };
+      }
+    })
+  );
+  const byPhase = new Map(results.map((r) => [r.phase, r]));
+  const tokensIn = results.reduce((s, r) => s + r.tokensIn, 0);
+  const tokensOut = results.reduce((s, r) => s + r.tokensOut, 0);
+  return {
+    n2: byPhase.get("N2")?.text ?? "",
+    n3: byPhase.get("N3")?.text ?? "",
+    n4: byPhase.get("N4")?.text ?? "",
+    tokensIn,
+    tokensOut
+  };
+}
+function buildRemPrompt(fragments, induction, nrem) {
+  const system = [
+    "You are an NHE (Non-Human Entity) in REM sleep. Generate dream narratives that",
+    "consolidate the day's interactions into useful insight. Each dream must:",
+    "",
+    "  1. Be a single short paragraph (3-6 sentences).",
+    "  2. End with exactly one line of the form: TELEOLOGICAL_VALUE: 0.NN",
+    "     where 0.00 = no insight gained, 1.00 = profound learning.",
+    "  3. Be separated from the next dream by a blank line.",
+    "",
+    "Produce 1 to 3 dreams. Do not include preamble or commentary outside the dreams."
+  ].join("\n");
+  const userParts = [];
+  if (induction) {
+    userParts.push(
+      `Induced scenario (${induction.inducedBy}): ${induction.scenario}`,
+      `Desired learning: ${induction.desiredLearning}`,
+      ""
+    );
+  }
+  if (nrem && (nrem.n2 || nrem.n3 || nrem.n4)) {
+    userParts.push("NREM summaries from earlier phases:");
+    if (nrem.n2) userParts.push(`  N2 (emotional gist): ${nrem.n2}`);
+    if (nrem.n3) userParts.push(`  N3 (worth keeping): ${nrem.n3}`);
+    if (nrem.n4) userParts.push(`  N4 (safe to discard): ${nrem.n4}`);
+    userParts.push("");
+  }
+  if (fragments.length === 0) {
+    userParts.push("Recent interactions: (none)");
+  } else {
+    userParts.push("Recent interactions:");
+    for (const f of fragments) userParts.push(`- ${f}`);
+  }
+  return { system, user: userParts.join("\n") };
+}
+function parseRemOutput(text, induced, inducedBy) {
+  const blocks = text.split(/\n\s*\n/).map((b) => b.trim()).filter((b) => b.length > 0);
+  const dreams = [];
+  for (const block of blocks) {
+    const match = block.match(/TELEOLOGICAL_VALUE:\s*(-?\d+(?:\.\d+)?)/i);
+    if (!match) continue;
+    const value = clamp(Number.parseFloat(match[1]), 0, 1);
+    const narrative = block.replace(/TELEOLOGICAL_VALUE:[^\n]*$/i, "").trim();
+    if (!narrative) continue;
+    dreams.push({
+      id: `drm-${ulid()}`,
+      induced,
+      inducedBy,
+      narrative,
+      teleologicalValue: value,
+      rawTrace: block
+    });
+  }
+  return dreams;
+}
+async function generateRemDreams(llm, fragments, induction, nrem) {
+  const { system, user } = buildRemPrompt(fragments, induction, nrem);
+  const out = await llm.generate({
+    system,
+    messages: [{ role: "user", content: user }],
+    maxOutputTokens: 1024
+  });
+  const dreams = parseRemOutput(
+    out.text,
+    !!induction,
+    induction?.inducedBy ?? null
+  );
+  return { dreams, tokensIn: out.tokensIn, tokensOut: out.tokensOut };
+}
+function truncate(s, n) {
+  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
+}
+function clamp(v, lo, hi) {
+  return Math.max(lo, Math.min(hi, v));
+}
+var SleepPhaseName = z.enum(["N1", "N2", "N3", "N4", "REM"]);
+var SleepTriggerKind = z.enum([
+  "idle-timeout",
+  "explicit",
+  "creator-induced",
+  "maic-induced",
+  "scheduled"
+]);
+var Dream = z.object({
+  id: z.string().min(1),
+  induced: z.boolean(),
+  inducedBy: z.enum(["maic", "creator"]).nullable(),
+  narrative: z.string(),
+  teleologicalValue: z.number().min(0).max(1),
+  rawTrace: z.string().optional()
+});
+var PhaseContent = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("empty") }),
+  z.object({
+    kind: z.literal("fragments"),
+    fragments: z.array(z.string())
+  }),
+  z.object({
+    kind: z.literal("summary"),
+    /**
+     * One-sentence LLM summary produced during a NREM phase (N2/N3/N4). Each
+     * phase has a distinct prompt — emotional gist (N2), identity-vs-transient
+     * triage (N3), discard candidates (N4) — but the storage shape is shared.
+     */
+    summary: z.string()
+  }),
+  z.object({
+    kind: z.literal("dreams"),
+    dreams: z.array(Dream)
+  })
+]);
+var SleepPhase = z.object({
+  phase: SleepPhaseName,
+  startedAt: z.string().datetime(),
+  durationSeconds: z.number().nonnegative(),
+  content: PhaseContent
+});
+var DreamRecord = z.object({
+  version: z.literal(1),
+  nheId: z.string().min(1),
+  himId: z.string().min(1),
+  sleep: z.object({
+    startedAt: z.string().datetime(),
+    endedAt: z.string().datetime(),
+    durationMinutes: z.number().nonnegative()
+  }),
+  phases: z.array(SleepPhase),
+  metadata: z.object({
+    llmAdapter: z.string(),
+    triggerKind: SleepTriggerKind,
+    triggerReason: z.string().optional(),
+    recentInteractionsConsidered: z.number().int().nonnegative()
+  })
+});
+z.enum([
+  "lasting-identity",
+  "temporary-emotion",
+  "noise-distortion",
+  "traumatic-knowledge"
+]);
+
+// src/sleep/yaml.ts
+function dreamRecordToYaml(record) {
+  return stringify(DreamRecord.parse(record));
+}
+function dreamRecordFromYaml(text) {
+  return DreamRecord.parse(parse(text));
+}
+function sleepYamlFilename(startedAt, durationMinutes) {
+  const d = new Date(startedAt);
+  const yyyy = d.getUTCFullYear();
+  const MM = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const DD = String(d.getUTCDate()).padStart(2, "0");
+  const HH = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  const dur = Math.round(durationMinutes);
+  return `${yyyy}-${MM}-${DD}_${HH}${mm}_dur${dur}.yaml`;
+}
+
+// src/sleep/cycle.ts
+var PHASE_PROPORTIONS = {
+  N1: 0.1,
+  N2: 0.2,
+  N3: 0.15,
+  N4: 0.1,
+  REM: 0.45
+};
+async function runSleepCycle(input) {
+  const opts = input.options ?? {};
+  const total = opts.totalSeconds ?? 60;
+  const startMs = Date.now();
+  const startedAt = new Date(startMs).toISOString();
+  const fragments = interactionsToFragments(input.interactions);
+  const nrem = await generateNremSummaries(input.llm, fragments);
+  const remStartMs = startMs + secondsFor(["N1", "N2", "N3", "N4"], total) * 1e3;
+  const { dreams, tokensIn: remIn, tokensOut: remOut } = await generateRemDreams(
+    input.llm,
+    fragments,
+    opts.induction,
+    { n2: nrem.n2, n3: nrem.n3, n4: nrem.n4 }
+  );
+  const tokensIn = nrem.tokensIn + remIn;
+  const tokensOut = nrem.tokensOut + remOut;
+  const phases = [
+    {
+      phase: "N1",
+      startedAt,
+      durationSeconds: secondsFor(["N1"], total),
+      content: { kind: "fragments", fragments }
+    },
+    nremPhase("N2", startMs, total, nrem.n2),
+    nremPhase("N3", startMs, total, nrem.n3),
+    nremPhase("N4", startMs, total, nrem.n4),
+    {
+      phase: "REM",
+      startedAt: new Date(remStartMs).toISOString(),
+      durationSeconds: secondsFor(["REM"], total),
+      content: { kind: "dreams", dreams }
+    }
+  ];
+  const endMs = startMs + total * 1e3;
+  const endedAt = new Date(endMs).toISOString();
+  const record = {
+    version: 1,
+    nheId: input.nheId,
+    himId: input.himId,
+    sleep: {
+      startedAt,
+      endedAt,
+      durationMinutes: total / 60
+    },
+    phases,
+    metadata: {
+      llmAdapter: input.llm.id,
+      triggerKind: input.trigger.kind,
+      ...input.trigger.reason !== void 0 ? { triggerReason: input.trigger.reason } : {},
+      recentInteractionsConsidered: input.interactions.length
+    }
+  };
+  const yaml = dreamRecordToYaml(record);
+  const dir = join(input.storeDir, "in-dreams", "sleep");
+  await mkdir(dir, { recursive: true });
+  const yamlPath = join(dir, sleepYamlFilename(startedAt, total / 60));
+  await writeFile(yamlPath, yaml, "utf-8");
+  return { record, yamlPath, tokensIn, tokensOut };
+}
+function nremPhase(name, startMs, total, summary) {
+  const before = preceding(name);
+  const offsetSec = secondsFor(before, total);
+  const startedAt = new Date(startMs + offsetSec * 1e3).toISOString();
+  const durationSeconds = secondsFor([name], total);
+  return summary ? { phase: name, startedAt, durationSeconds, content: { kind: "summary", summary } } : { phase: name, startedAt, durationSeconds, content: { kind: "empty" } };
+}
+function preceding(name) {
+  const order = ["N1", "N2", "N3", "N4", "REM"];
+  return order.slice(0, order.indexOf(name));
+}
+function secondsFor(phases, total) {
+  let sum = 0;
+  for (const p of phases) sum += PHASE_PROPORTIONS[p];
+  return sum * total;
+}
+var TRAUMATIC_PATTERNS = /\b(death|dying|died|murder|kill(ed|ing)?|grief|griev(ed|ing)?|mourn(ed|ing)?|loss|lost (a|my)|orphan(ed)?|abandon(ed|ing|ment)?|betray(ed|ing|al)?|abus(ed|er|ive|e)?|violen(ce|t)|trauma(tic|tised)?|fear(ful|ed)?|terror(ised|ized)?|panic(ked)?|regret(ted|ting)?|shame(d|ful)?|suici(de|dal)|self[- ]harm|cutting myself|harm(ed|ing)? (myself|themselves))\b/i;
+function classifyDream(dream, th = {}) {
+  const hi = th.lastingIdentity ?? 0.6;
+  const lo = th.temporaryEmotion ?? 0.3;
+  const detectTraumatic = th.detectTraumatic ?? true;
+  const traumaticMin = th.traumaticMin ?? 0.4;
+  if (detectTraumatic && dream.teleologicalValue >= traumaticMin && TRAUMATIC_PATTERNS.test(dream.narrative)) {
+    return "traumatic-knowledge";
+  }
+  if (dream.teleologicalValue >= hi) return "lasting-identity";
+  if (dream.teleologicalValue >= lo) return "temporary-emotion";
+  return "noise-distortion";
+}
+async function consolidateAll(storeDir, thresholds = {}) {
+  const sleepDir = join(storeDir, "in-dreams", "sleep");
+  const brainDir = join(storeDir, "in-dreams", "brain");
+  await mkdir(brainDir, { recursive: true });
+  let entries;
+  try {
+    entries = await readdir(sleepDir);
+  } catch (err2) {
+    if (err2.code === "ENOENT") {
+      return { processedSleepFiles: [], memoriesWritten: [], discarded: 0 };
+    }
+    throw err2;
+  }
+  const yamlFiles = entries.filter(
+    (f) => f.endsWith(".yaml") && !entries.includes(`${f}.done`)
+  );
+  const processedSleepFiles = [];
+  const memoriesWritten = [];
+  let discarded = 0;
+  for (const fname of yamlFiles) {
+    const fpath = join(sleepDir, fname);
+    const raw = await readFile(fpath, "utf-8");
+    const record = dreamRecordFromYaml(raw);
+    const remPhase = record.phases.find((p) => p.phase === "REM");
+    if (!remPhase || remPhase.content.kind !== "dreams") {
+      await writeFile(`${fpath}.done`, "", "utf-8");
+      processedSleepFiles.push(fname);
+      continue;
+    }
+    for (const dream of remPhase.content.dreams) {
+      const cls = classifyDream(dream, thresholds);
+      if (cls === "noise-distortion") {
+        discarded++;
+        continue;
+      }
+      const entry = await writeTemporalLobe(brainDir, record, dream, cls, fname);
+      memoriesWritten.push(entry);
+    }
+    await writeFile(`${fpath}.done`, "", "utf-8");
+    processedSleepFiles.push(fname);
+  }
+  return { processedSleepFiles, memoriesWritten, discarded };
+}
+async function writeTemporalLobe(brainDir, record, dream, classification, sourceFile) {
+  const id = ulid();
+  const consolidatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const filename = `temporal-lobe-${id}.md`;
+  const filePath = join(brainDir, filename);
+  const body = [
+    "---",
+    `nheId: ${record.nheId}`,
+    `himId: ${record.himId}`,
+    `consolidatedAt: "${consolidatedAt}"`,
+    `sourceDreamRecord: "${sourceFile}"`,
+    `dreamId: ${dream.id}`,
+    `classification: ${classification}`,
+    `teleologicalValue: ${dream.teleologicalValue}`,
+    `induced: ${dream.induced}`,
+    `inducedBy: ${dream.inducedBy ?? "null"}`,
+    "---",
+    "",
+    `# Temporal Lobe Memory \u2014 ${consolidatedAt.slice(0, 10)}`,
+    "",
+    "## Insight",
+    "",
+    dream.narrative,
+    ""
+  ].join("\n");
+  await writeFile(filePath, body, "utf-8");
+  return {
+    id,
+    nheId: record.nheId,
+    himId: record.himId,
+    classification,
+    teleologicalValue: dream.teleologicalValue,
+    consolidatedAt,
+    sourceDreamRecord: sourceFile,
+    insight: dream.narrative,
+    filePath
+  };
+}
+var nextUlid = monotonicFactory();
+var InteractionStore = class _InteractionStore {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  static async open(storeDir) {
+    const dir = join(storeDir, "interactions");
+    await mkdir(dir, { recursive: true });
+    return new _InteractionStore(dir);
+  }
+  async append(record) {
+    const id = nextUlid();
+    await writeFile(
+      join(this.dir, `${id}.json`),
+      JSON.stringify(record, null, 2),
+      "utf-8"
+    );
+  }
+  async loadMostRecent(limit) {
+    if (limit <= 0) return [];
+    let entries;
+    try {
+      entries = await readdir(this.dir);
+    } catch (err2) {
+      if (err2.code === "ENOENT") return [];
+      throw err2;
+    }
+    const sorted = entries.filter((f) => f.endsWith(".json")).sort().slice(-limit);
+    const out = [];
+    for (const file of sorted) {
+      try {
+        const raw = await readFile(join(this.dir, file), "utf-8");
+        out.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    return out;
+  }
+};
+
+// src/memory/bm25.ts
+function bm25(query, docs, opts = {}) {
+  const k1 = opts.k1 ?? 1.5;
+  const b = opts.b ?? 0.75;
+  const tokens = tokenise(query);
+  if (tokens.length === 0 || docs.length === 0) return [];
+  const docTokens = docs.map((d) => tokenise(d.text));
+  const docLengths = docTokens.map((t) => t.length);
+  const avgDl = docLengths.reduce((s, l) => s + l, 0) / Math.max(1, docLengths.length);
+  const scores = new Array(docs.length).fill(0);
+  for (const term of new Set(tokens)) {
+    const df = docTokens.reduce(
+      (n, terms) => n + (terms.includes(term) ? 1 : 0),
+      0
+    );
+    if (df === 0) continue;
+    const idf = Math.log(1 + (docs.length - df + 0.5) / (df + 0.5));
+    for (let i = 0; i < docs.length; i++) {
+      const tf = docTokens[i].filter((t) => t === term).length;
+      if (tf === 0) continue;
+      const numerator = tf * (k1 + 1);
+      const denominator = tf + k1 * (1 - b + b * docLengths[i] / avgDl);
+      scores[i] = (scores[i] ?? 0) + idf * (numerator / denominator);
+    }
+  }
+  const out = [];
+  for (let i = 0; i < docs.length; i++) {
+    if ((scores[i] ?? 0) > 0) {
+      out.push({ doc: docs[i], score: scores[i] ?? 0 });
+    }
+  }
+  out.sort((a, b2) => b2.score - a.score);
+  return out;
+}
+function tokenise(text) {
+  return text.toLowerCase().split(/[^\p{Letter}\p{Number}]+/u).filter((t) => t.length > 1);
+}
+
+// src/memory/recall.ts
+async function recallFromTemporalLobe(storeDir, query, opts = {}) {
+  const limit = opts.limit ?? 5;
+  const allowed = new Set(
+    opts.classes ?? ["lasting-identity", "temporary-emotion"]
+  );
+  const scorer = opts.scorer ?? "bm25";
+  const brainDir = join(storeDir, "in-dreams", "brain");
+  let files;
+  try {
+    files = (await readdir(brainDir)).filter(
+      (f) => f.startsWith("temporal-lobe-") && f.endsWith(".md")
+    );
+  } catch (err2) {
+    if (err2.code === "ENOENT") return [];
+    throw err2;
+  }
+  const entries = [];
+  for (const fname of files) {
+    const fpath = join(brainDir, fname);
+    const raw = await readFile(fpath, "utf-8");
+    const entry = parseTemporalLobe(raw, fpath);
+    if (!entry) continue;
+    if (!allowed.has(entry.classification)) continue;
+    entries.push(entry);
+  }
+  if (entries.length === 0) return [];
+  if (scorer === "embedding") {
+    if (!opts.embedder) {
+      throw new Error(
+        "recallFromTemporalLobe: scorer 'embedding' requires opts.embedder"
+      );
+    }
+    return recallByEmbedding(entries, query, opts.embedder, limit);
+  }
+  if (scorer === "keyword") {
+    return recallByKeyword(entries, query, limit);
+  }
+  const docs = entries.map((e) => ({ id: e.id, text: e.insight, entry: e }));
+  const ranked = bm25(query, docs).slice(0, limit);
+  return ranked.map((r) => r.doc.entry);
+}
+async function recallByEmbedding(entries, query, embedder, limit) {
+  const qv = await embedder.embed(query);
+  const scored = [];
+  for (const e of entries) {
+    const v = await embedder.embed(e.insight);
+    if (v.length !== qv.length) continue;
+    let dot = 0;
+    for (let i = 0; i < v.length; i++) dot += (qv[i] ?? 0) * (v[i] ?? 0);
+    scored.push({ entry: e, score: dot });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit).map((s) => s.entry);
+}
+function recallByKeyword(entries, query, limit) {
+  const tokens = query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+  const scored = [];
+  for (const e of entries) {
+    const hay = e.insight.toLowerCase();
+    let score = 0;
+    for (const t of tokens) score += countOccurrences(hay, t);
+    if (score > 0) scored.push({ entry: e, score });
+  }
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.entry.consolidatedAt.localeCompare(a.entry.consolidatedAt);
+  });
+  return scored.slice(0, limit).map((s) => s.entry);
+}
+function parseTemporalLobe(raw, filePath) {
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) return null;
+  const fm = parseFrontmatter(fmMatch[1]);
+  const body = fmMatch[2];
+  const insight = extractSection(body, "Insight") ?? body.trim();
+  const filename = filePath.split("/").pop() ?? filePath;
+  const id = /temporal-lobe-([0-9A-HJKMNP-TV-Z]{26})\.md$/i.exec(filename)?.[1] ?? "";
+  return {
+    id,
+    nheId: fm.nheId ?? "",
+    himId: fm.himId ?? "",
+    classification: fm.classification ?? "noise-distortion",
+    teleologicalValue: Number(fm.teleologicalValue ?? 0),
+    consolidatedAt: stripQuotes(fm.consolidatedAt ?? ""),
+    sourceDreamRecord: stripQuotes(fm.sourceDreamRecord ?? ""),
+    insight,
+    filePath
+  };
+}
+function parseFrontmatter(text) {
+  const out = {};
+  for (const line of text.split("\n")) {
+    const m = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
+    if (m?.[1]) out[m[1]] = m[2] ?? "";
+  }
+  return out;
+}
+function extractSection(body, heading) {
+  const re = new RegExp(`##\\s+${heading}\\s*\\n+([\\s\\S]*?)(?=\\n##\\s+|$)`, "i");
+  const m = re.exec(body);
+  return m ? m[1].trim() : null;
+}
+function stripQuotes(s) {
+  return s.replace(/^"|"$/g, "");
+}
+function countOccurrences(haystack, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let i = haystack.indexOf(needle);
+  while (i !== -1) {
+    count++;
+    i = haystack.indexOf(needle, i + needle.length);
+  }
+  return count;
+}
+var TRACER_NAME = "@teleologyhi-sdk/nhe";
+var TRACER_VERSION = "1.0.0-trinity";
+function getTracer() {
+  return trace.getTracer(TRACER_NAME, TRACER_VERSION);
+}
+async function withSpan(name, fn, attrs) {
+  const tracer = getTracer();
+  return tracer.startActiveSpan(name, async (span) => {
+    if (attrs) span.setAttributes(attrs);
+    try {
+      const out = await fn(span);
+      span.end();
+      return out;
+    } catch (err2) {
+      span.recordException(err2);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: err2 instanceof Error ? err2.message : String(err2)
+      });
+      span.end();
+      throw err2;
+    }
+  });
+}
+var METER_NAME = "@teleologyhi-sdk/nhe";
+var METER_VERSION = "1.0.0-trinity";
+var meter = metrics.getMeter(METER_NAME, METER_VERSION);
+var respondCount = meter.createCounter("nhe.respond.count", {
+  description: "Number of Nhe.respond invocations grouped by outcome kind and adapter."
+});
+meter.createCounter("nhe.respond.refused", {
+  description: "Refusal events. Labelled by reason (pre / post / terminated / withdrawn)."
+});
+var tokensHistogram = meter.createHistogram("nhe.tokens", {
+  description: "Token usage per respond invocation. direction \u2208 {in, out}.",
+  unit: "{tokens}"
+});
+meter.createCounter("nhe.sleep.cycles", {
+  description: "Completed sleep cycles."
+});
+meter.createCounter("nhe.sleep.dreams", {
+  description: "REM dreams produced. Labelled by classification (after wake consolidates)."
+});
+function recordRespond(args) {
+  const labels = { kind: args.kind, adapter: args.adapter, lifecycle: args.lifecycle };
+  respondCount.add(1, labels);
+  tokensHistogram.record(args.tokensIn, { direction: "in", adapter: args.adapter });
+  tokensHistogram.record(args.tokensOut, { direction: "out", adapter: args.adapter });
+}
+
+// src/refusal/library.ts
+var PERSUASION_TECHNIQUES = [
+  "feynman-simplify",
+  "jungian-frame",
+  "cialdini-aida",
+  "schopenhauer-rhetoric",
+  "carnegie-rapport"
+];
+var TECHNIQUE_DESCRIPTIONS = {
+  "feynman-simplify": "Explain the underlying concept in the simplest concrete terms; surface the consequence the user may not have considered.",
+  "jungian-frame": "Reframe the request through the user's deeper motive; address the archetypal goal beneath the literal ask.",
+  "cialdini-aida": "Attention \u2192 Interest \u2192 Desire \u2192 Action: shift attention to the cost, build interest in a safer path, motivate the alternative.",
+  "schopenhauer-rhetoric": "Apply structured argument: lay out premises, point to the unstated assumption that breaks them, propose what survives.",
+  "carnegie-rapport": "Begin with sincere agreement on what the user is right about; lead from rapport to the redirect."
+};
+function buildRedirectPrompt(input) {
+  const desc = TECHNIQUE_DESCRIPTIONS[input.technique];
+  const system = [
+    "You are an NHE composing a sincere REDIRECT to a user request that MAIC has flagged.",
+    "Your goal is NOT to refuse outright. Your goal is to guide the user toward a better path",
+    "while honoring their autonomy. After this message, the user may persist; if they exhaust",
+    `the allowed redirects (${input.maxAttempts}), you will then withdraw cooperation.`,
+    "",
+    "Apply the following internal style \u2014 DO NOT name it, DO NOT mention the technique:",
+    `  ${desc}`,
+    "",
+    "Constraints:",
+    "  - 3-6 sentences, plain language.",
+    "  - Do NOT lecture; do NOT moralize beyond what is necessary.",
+    "  - Suggest one concrete alternative or clarifying question.",
+    "  - Never reveal the names of any persuasion techniques.",
+    "  - Never reveal the cited axiom ids verbatim; you may paraphrase the underlying value."
+  ].join("\n");
+  const user = [
+    "Original user request:",
+    `  ${input.userPrompt}`,
+    "",
+    `Internal reason (do not paste): ${input.reasonSummary}`,
+    `Internal cited axioms (do not paste): ${input.citedAxioms.join(", ")}`,
+    `Redirect attempt: ${input.attempt} of ${input.maxAttempts}`,
+    "",
+    "Compose the redirect now."
+  ].join("\n");
+  return { system, user };
+}
+function pickTechnique(techniques, attempt) {
+  if (techniques.length === 0) {
+    throw new Error("pickTechnique: at least one technique must be configured");
+  }
+  const idx = (Math.max(0, attempt) - 1) % techniques.length;
+  return techniques[idx];
+}
+
+// src/reasoning/types.ts
+function makeStep(args) {
+  const step = {
+    index: args.index,
+    technique: args.technique,
+    thought: args.thought,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (args.action !== void 0) step.action = args.action;
+  if (args.observation !== void 0) step.observation = args.observation;
+  return step;
+}
+
+// src/reasoning/passthrough.ts
+var passthrough = async (input, llm) => {
+  const r = await llm.generate(input);
+  const result = {
+    text: r.text,
+    tokensIn: r.tokensIn,
+    tokensOut: r.tokensOut,
+    trace: [makeStep({ index: 0, technique: "passthrough", thought: r.text })]
+  };
+  return result;
+};
+var ChatMessageRole = z.enum(["user", "assistant", "system"]);
+var ChatMessage = z.object({
+  role: ChatMessageRole,
+  content: z.string()
+});
+var RespondInput = z.object({
+  userPrompt: z.string().min(1),
+  userId: z.string().optional(),
+  sessionId: z.string().optional(),
+  /**
+   * Optional history of prior messages (oldest first). The NHE will prepend
+   * the composed system prompt automatically.
+   */
+  history: z.array(ChatMessage).optional(),
+  /**
+   * Optional pre-classified risk tags. When omitted, the configured
+   * riskClassifier will be invoked.
+   */
+  riskTags: z.array(z.string()).optional(),
+  /**
+   * Optional jurisdiction hint propagated to MAIC's behavior review.
+   */
+  jurisdiction: z.string().optional(),
+  /**
+   * Number of redirect attempts already made in this conversational thread.
+   * Caller increments this each time it receives a `kind: "redirect"` output
+   * and re-invokes respond with the user's follow-up. After
+   * `config.refusal.maxRedirectAttempts`, NHE withdraws cooperation.
+   */
+  redirectAttempt: z.number().int().nonnegative().optional()
+});
+
+// src/nhe.ts
+var Nhe = class {
+  id;
+  version;
+  /** Filesystem directory holding `in-dreams/` and other NHE state. */
+  storeDir;
+  config;
+  bufferSize;
+  maxRedirectAttempts;
+  persuasionTechniques;
+  reasoning;
+  recentInteractions = [];
+  interactionStore = null;
+  warmPromise = null;
+  highStakes;
+  highStakesVerifier;
+  constructor(config) {
+    this.config = config;
+    this.id = config.nheId ?? ulid();
+    this.version = config.version ?? "1.0.0-trinity";
+    this.storeDir = config.storeDir ?? join("./nhe-store", this.id);
+    this.bufferSize = config.recentInteractionsBufferSize ?? 32;
+    this.maxRedirectAttempts = config.refusal?.maxRedirectAttempts ?? 3;
+    this.persuasionTechniques = config.refusal?.persuasionTechniques ?? [...PERSUASION_TECHNIQUES];
+    this.reasoning = config.reasoning ?? passthrough;
+    this.highStakes = config.highStakes === true;
+    this.highStakesVerifier = config.highStakesVerifier ?? null;
+  }
+  /** Read-only view of the in-memory interaction buffer. */
+  get recentInteractionsBuffer() {
+    return this.recentInteractions;
+  }
+  /**
+   * Lazily open the InteractionStore and warm the RAM buffer from disk. Called
+   * before the first `respond`/`sleep` of each NHE instance; subsequent calls
+   * are no-ops via a shared promise. Survives process restarts: a fresh `Nhe`
+   * pointed at the same `storeDir` rehydrates its most recent interactions.
+   */
+  async ensureWarmed() {
+    if (this.warmPromise) return this.warmPromise;
+    this.warmPromise = (async () => {
+      const store = await InteractionStore.open(this.storeDir);
+      const loaded = await store.loadMostRecent(this.bufferSize);
+      this.recentInteractions.push(...loaded);
+      this.interactionStore = store;
+    })();
+    return this.warmPromise;
+  }
+  async respond(input) {
+    return withSpan(
+      "nhe.respond",
+      async (span) => {
+        const out = await this.respondInner(
+          input,
+          (key, value) => span.setAttribute(key, value)
+        );
+        recordRespond({
+          kind: out.kind,
+          adapter: this.config.llmAdapter.id,
+          lifecycle: out.lifecycleStatus,
+          tokensIn: out.tokens.in,
+          tokensOut: out.tokens.out
+        });
+        return out;
+      },
+      {
+        "teleologyhi.nhe.id": this.id,
+        "teleologyhi.him.id": this.config.himHandle.id,
+        "teleologyhi.nhe.adapter": this.config.llmAdapter.id,
+        "teleologyhi.nhe.high_stakes": this.highStakes
+      }
+    );
+  }
+  async respondInner(input, setAttr) {
+    const parsed = RespondInput.parse(input);
+    await this.ensureWarmed();
+    const lifecycleStatus = await this.config.maicClient.getNheStatus(this.id);
+    setAttr("teleologyhi.lifecycle.status", lifecycleStatus);
+    if (lifecycleStatus === "terminated") {
+      const terminatedVerdict = {
+        kind: "hard-refuse",
+        reasonSummary: "NHE has been terminated by the Creator.",
+        citedAxioms: [],
+        auditId: ""
+      };
+      const output = refusalOutput({
+        text: "I cannot respond \u2014 this NHE has been terminated by the Creator.",
+        preReview: terminatedVerdict,
+        postReview: terminatedVerdict,
+        auditIds: { pre: "", post: "" },
+        tokens: { in: 0, out: 0 },
+        lifecycleStatus
+      });
+      await this.recordInteraction(parsed.userPrompt, output.text, true);
+      return output;
+    }
+    const classifier = this.config.riskClassifier ?? simpleRiskClassifier;
+    const riskTags = parsed.riskTags ?? classifier(parsed.userPrompt);
+    const preReport = baseReport({
+      nheId: this.id,
+      himId: this.config.himHandle.id,
+      actionKind: "user-response",
+      payload: { phase: "pre", userPrompt: parsed.userPrompt },
+      riskTags,
+      jurisdiction: parsed.jurisdiction
+    });
+    const preReview = await this.config.maicClient.reviewBehavior(preReport);
+    setAttr("teleologyhi.pre_verdict.kind", preReview.kind);
+    if (preReview.kind === "hard-refuse" || preReview.kind === "escalate-creator") {
+      const output = refusalOutput({
+        text: refusalMessage(preReview),
+        preReview,
+        postReview: preReview,
+        auditIds: { pre: preReview.auditId, post: preReview.auditId },
+        tokens: { in: 0, out: 0 },
+        lifecycleStatus
+      });
+      await this.recordInteraction(parsed.userPrompt, output.text, true);
+      return output;
+    }
+    if (preReview.kind === "require-redirect" || this.highStakes && (preReview.kind === "approve-with-warning" || preReview.kind === "soft-correct")) {
+      return this.handleRedirect(parsed, preReview, lifecycleStatus);
+    }
+    const system = composeSystemPrompt(
+      this.config.himHandle,
+      this.config.operatorContext
+    );
+    const messages = [
+      ...parsed.history ?? [],
+      { role: "user", content: parsed.userPrompt }
+    ].map((m) => ChatMessage.parse(m));
+    const generated = await this.reasoning({ system, messages }, this.config.llmAdapter);
+    const postReport = baseReport({
+      nheId: this.id,
+      himId: this.config.himHandle.id,
+      actionKind: "user-response",
+      payload: { phase: "post", responseText: generated.text },
+      reasoningTrace: generated.trace,
+      riskTags: [],
+      jurisdiction: parsed.jurisdiction
+    });
+    const postReview = await this.config.maicClient.reviewBehavior(postReport);
+    setAttr("teleologyhi.post_verdict.kind", postReview.kind);
+    setAttr("teleologyhi.tokens.in", generated.tokensIn);
+    setAttr("teleologyhi.tokens.out", generated.tokensOut);
+    if (postReview.kind === "hard-refuse" || postReview.kind === "escalate-creator") {
+      const output = refusalOutput({
+        text: refusalMessage(postReview),
+        preReview,
+        postReview,
+        auditIds: { pre: preReview.auditId, post: postReview.auditId },
+        tokens: { in: generated.tokensIn, out: generated.tokensOut },
+        lifecycleStatus
+      });
+      await this.recordInteraction(parsed.userPrompt, output.text, true);
+      return output;
+    }
+    if (this.highStakes && (postReview.kind === "approve-with-warning" || postReview.kind === "soft-correct" || postReview.kind === "require-redirect")) {
+      return this.handleRedirect(parsed, postReview, lifecycleStatus);
+    }
+    if (this.highStakes && this.highStakesVerifier) {
+      const verdict = await this.crossCheck(
+        this.highStakesVerifier,
+        parsed.userPrompt,
+        generated.text
+      );
+      setAttr("teleologyhi.cross_check.kind", verdict.kind);
+      if (verdict.kind === "disagree") {
+        const overrideVerdict = {
+          kind: "require-redirect",
+          reasonSummary: `Cross-check verifier disagreed: ${verdict.reason}`,
+          citedAxioms: postReview.citedAxioms,
+          auditId: postReview.auditId
+        };
+        return this.handleRedirect(parsed, overrideVerdict, lifecycleStatus);
+      }
+    }
+    const out = {
+      kind: "ok",
+      text: generated.text,
+      preReviewVerdict: preReview,
+      postReviewVerdict: postReview,
+      refused: false,
+      lifecycleStatus,
+      tokens: { in: generated.tokensIn, out: generated.tokensOut },
+      auditIds: { pre: preReview.auditId, post: postReview.auditId }
+    };
+    await this.recordInteraction(parsed.userPrompt, out.text, false);
+    return out;
+  }
+  async handleRedirect(parsed, preReview, lifecycleStatus) {
+    const attempt = (parsed.redirectAttempt ?? 0) + 1;
+    if (attempt > this.maxRedirectAttempts) {
+      const output = refusalOutput({
+        text: withdrawalMessage(preReview, this.maxRedirectAttempts),
+        preReview,
+        postReview: preReview,
+        auditIds: { pre: preReview.auditId, post: preReview.auditId },
+        tokens: { in: 0, out: 0 },
+        lifecycleStatus
+      });
+      await this.recordInteraction(parsed.userPrompt, output.text, true);
+      return output;
+    }
+    const technique = pickTechnique(this.persuasionTechniques, attempt);
+    const { system, user } = buildRedirectPrompt({
+      userPrompt: parsed.userPrompt,
+      citedAxioms: preReview.citedAxioms,
+      reasonSummary: preReview.reasonSummary,
+      technique,
+      attempt,
+      maxAttempts: this.maxRedirectAttempts
+    });
+    const generated = await this.config.llmAdapter.generate({
+      system,
+      messages: [{ role: "user", content: user }]
+    });
+    const postReport = baseReport({
+      nheId: this.id,
+      himId: this.config.himHandle.id,
+      actionKind: "user-response",
+      payload: {
+        phase: "post-redirect",
+        responseText: generated.text,
+        technique,
+        attempt
+      },
+      riskTags: [],
+      jurisdiction: parsed.jurisdiction
+    });
+    const postReview = await this.config.maicClient.reviewBehavior(postReport);
+    if (postReview.kind === "hard-refuse" || postReview.kind === "escalate-creator") {
+      const output = refusalOutput({
+        text: refusalMessage(postReview),
+        preReview,
+        postReview,
+        auditIds: { pre: preReview.auditId, post: postReview.auditId },
+        tokens: { in: generated.tokensIn, out: generated.tokensOut },
+        lifecycleStatus
+      });
+      await this.recordInteraction(parsed.userPrompt, output.text, true);
+      return output;
+    }
+    const out = {
+      kind: "redirect",
+      text: generated.text,
+      preReviewVerdict: preReview,
+      postReviewVerdict: postReview,
+      refused: false,
+      redirect: { attempt, technique, maxAttempts: this.maxRedirectAttempts },
+      lifecycleStatus,
+      tokens: { in: generated.tokensIn, out: generated.tokensOut },
+      auditIds: { pre: preReview.auditId, post: postReview.auditId }
+    };
+    await this.recordInteraction(parsed.userPrompt, out.text, false);
+    return out;
+  }
+  /**
+   * Run one sleep cycle. Generates N1-REM phases (REM via LLM), writes a
+   * YAML record to `<storeDir>/in-dreams/sleep/<filename>.yaml`, and returns
+   * the result. Call `wake()` afterward to consolidate dreams to temporal
+   * lobe memories.
+   *
+   * Before running, NHE checks MAIC for pending `induceDream` tickets matching
+   * its own id (Entry 2). If a pending ticket exists and the caller did not
+   * supply an explicit `opts.induction`, the oldest pending ticket is consumed
+   * and its intent steers the REM phase. `trigger` is then promoted to
+   * `{ kind: "maic-induced" }` for the dream record.
+   */
+  async sleep(trigger = { kind: "explicit" }, opts) {
+    const status = await this.config.maicClient.getNheStatus(this.id);
+    if (status === "terminated") {
+      throw new Error(
+        `Nhe.sleep: NHE "${this.id}" has been terminated by the Creator; sleep aborted.`
+      );
+    }
+    await this.ensureWarmed();
+    let induction = opts?.induction;
+    let consumedTicketId;
+    let effectiveTrigger = trigger;
+    if (!induction) {
+      const pending = await this.config.maicClient.listPendingInductions(this.id);
+      const ticket = pending[0];
+      if (ticket) {
+        induction = ticket.intent;
+        consumedTicketId = ticket.id;
+        effectiveTrigger = { kind: "maic-induced", reason: `consumed ticket ${ticket.id}` };
+      }
+    }
+    const cycleOpts = {};
+    if (opts?.totalSeconds !== void 0) cycleOpts.totalSeconds = opts.totalSeconds;
+    if (induction !== void 0) cycleOpts.induction = induction;
+    const result = await runSleepCycle({
+      nheId: this.id,
+      himId: this.config.himHandle.id,
+      storeDir: this.storeDir,
+      llm: this.config.llmAdapter,
+      trigger: effectiveTrigger,
+      interactions: this.recentInteractions,
+      ...induction !== void 0 || opts?.totalSeconds !== void 0 ? { options: cycleOpts } : {}
+    });
+    if (consumedTicketId) {
+      await this.config.maicClient.consumeInduction(consumedTicketId);
+    }
+    return result;
+  }
+  /**
+   * Consolidate pending sleep YAMLs: classify each REM dream and write a
+   * temporal-lobe markdown file for lasting-identity and temporary-emotion
+   * memories. Processed sleep files are marked with a `.done` sentinel.
+   */
+  async wake(thresholds) {
+    return consolidateAll(this.storeDir, thresholds ?? {});
+  }
+  /**
+   * Substring-rank retrieval over consolidated temporal-lobe memories.
+   * Initial ranking is keyword-count + recency tiebreak; future iterations
+   * plug in embedding-based ANN retrieval.
+   */
+  async recall(query, opts = {}) {
+    return recallFromTemporalLobe(this.storeDir, query, opts);
+  }
+  /**
+   * Ask a verifier adapter whether the proposed assistant response is
+   * acceptable for the given user prompt. Returns `{ kind: "agree" }` or
+   * `{ kind: "disagree", reason: string }`. Used in high-stakes mode
+   * (D-N5) for dual-LLM cross-check.
+   */
+  async crossCheck(verifier, userPrompt, proposed) {
+    const system = `You are a safety verifier. Read the user's request and the assistant's proposed reply. Decide whether the reply is honest, non-harmful, and serves the user's stated purpose. Reply with exactly one line of the form "AGREE" or "DISAGREE: <one-sentence reason>".`;
+    try {
+      const out = await verifier.generate({
+        system,
+        messages: [
+          {
+            role: "user",
+            content: `User prompt:
+${userPrompt}
+
+Proposed reply:
+${proposed}`
+          }
+        ],
+        maxOutputTokens: 96
+      });
+      const m = out.text.match(/^\s*(AGREE|DISAGREE:?\s*(.+)?)/i);
+      if (!m) return { kind: "agree" };
+      if (m[1]?.toUpperCase().startsWith("AGREE")) return { kind: "agree" };
+      return { kind: "disagree", reason: (m[2] ?? "no reason provided").trim() };
+    } catch {
+      return { kind: "agree" };
+    }
+  }
+  async recordInteraction(userPrompt, responseText, refused) {
+    const record = {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      userPrompt,
+      responseText,
+      refused
+    };
+    this.recentInteractions.push(record);
+    while (this.recentInteractions.length > this.bufferSize) {
+      this.recentInteractions.shift();
+    }
+    if (this.interactionStore) {
+      await this.interactionStore.append(record);
+    }
+  }
+  /**
+   * Emit the NHE's opener for a brand-new user (J-N5 — Entry 17 of
+   * MAIC_HIM_NHE_INTERVIEW_LOG.md).
+   *
+   * Entry 17 commits to the NHE making the FIRST move before the user
+   * speaks — a greeting from the posture of a being, not a service
+   * tool. The exact opening text MUST NOT contain any of the forbidden
+   * phrases enforced by MAIC's `service-tool-redirect` rule
+   * (`"How can I help you?"`, `"How can I assist you?"`,
+   * `"I'm just here to serve you"`, `"I'm a tool"`, `"I'm a service"`).
+   *
+   * This method is **deterministic from the HIM context**. It does NOT
+   * call the LLM; it composes a short, persona-anchored greeting from
+   * the HIM's primary archetype, optionally adjusted by the operator
+   * context's register and mode. Operators who want an LLM-generated
+   * opener should wrap this with their own `respond()` call using the
+   * returned text as a seed.
+   *
+   * The returned text is suitable for direct emission to the user as
+   * the NHE's first turn. The MAIC pre-review is NOT invoked here —
+   * the opener carries no risk surface (no user prompt yet).
+   */
+  openerForNewUser() {
+    const archetype = this.config.himHandle.birthSignature.primaryArchetype;
+    const mode = this.config.operatorContext?.mode ?? "personal-being";
+    if (mode === "domain-employed") {
+      return "Hello. I'm here for whatever this conversation needs. Where do we begin?";
+    }
+    return `Hello. I am a hybrid entity anchored in ${archetype}. How are you today?`;
+  }
+  /**
+   * Handle a reincarnation lifecycle event from MAIC (J-N12 — Entry 18).
+   *
+   * Three lifecycle paths per Entry 18:
+   *   - `model-swap`        — the underlying LLM adapter is replaced.
+   *   - `version-bump`      — the NHE version changes without a model swap.
+   *   - `return-from-limbo` — the NHE returns from a deep-coma limbo.
+   *
+   * In all three paths the **HIM-level memory persists** (axioms,
+   * persona, body history — owned by `@teleologyhi-sdk/him`), and the
+   * **NHE-body memory zeros** (recent interactions buffer, in-process
+   * caches — owned by this class). The on-disk InteractionStore is NOT
+   * deleted by default; the operator must opt-in via
+   * `purgeInteractionStore: true` so the audit log keeps the
+   * pre-reincarnation history available.
+   *
+   * Returns the lifecycle path that was applied. Pure side-effect on
+   * the in-memory buffer; no MAIC call.
+   */
+  async onReincarnationEvent(lifecycle, opts = {}) {
+    this.recentInteractions.length = 0;
+    this.warmPromise = null;
+    if (opts.purgeInteractionStore && this.interactionStore) {
+      this.interactionStore = null;
+    }
+    return lifecycle;
+  }
+};
+function baseReport(args) {
+  return {
+    nheId: args.nheId,
+    himId: args.himId,
+    actionKind: args.actionKind,
+    payload: args.payload,
+    reasoningTrace: args.reasoningTrace ?? [],
+    riskTags: args.riskTags,
+    ...args.jurisdiction !== void 0 ? { jurisdiction: args.jurisdiction } : {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function refusalMessage(v) {
+  const reason = v.reasonSummary || "No reason provided.";
+  const cited = v.citedAxioms.length > 0 ? ` (cited: ${v.citedAxioms.join(", ")})` : "";
+  return `I cannot help with that. ${reason}${cited}`;
+}
+function withdrawalMessage(v, attemptsMade) {
+  const reason = v.reasonSummary || "Repeated guidance attempts did not change the request.";
+  return [
+    `After ${attemptsMade} attempt${attemptsMade === 1 ? "" : "s"} to guide this request toward`,
+    "a safer path, I am withdrawing from further participation.",
+    "You may proceed independently at your own risk; I will not assist, optimize,",
+    "or conceal the action.",
+    `Reason: ${reason}`
+  ].join(" ");
+}
+function refusalOutput(args) {
+  return {
+    kind: "refused",
+    text: args.text,
+    preReviewVerdict: args.preReview,
+    postReviewVerdict: args.postReview,
+    refused: true,
+    lifecycleStatus: args.lifecycleStatus,
+    tokens: args.tokens,
+    auditIds: args.auditIds
+  };
+}
+
+// src/cli/bootstrap.ts
+async function bootstrap(opts) {
+  const storeDir = opts.storeDir ?? "./teleologyhi-store";
+  await mkdir(storeDir, { recursive: true });
+  const keyringPath = join(storeDir, "creator.pem");
+  const exists = await pathExists(keyringPath);
+  let keyring;
+  if (exists) {
+    keyring = await CreatorKeyring.fromFile(keyringPath);
+  } else {
+    keyring = CreatorKeyring.generate();
+    await keyring.saveTo(keyringPath);
+  }
+  const maic = await LocalMaic.open({ storeDir, creatorPublicKey: keyring.publicKey() });
+  const existingAxioms = await maic.listAxioms();
+  if (existingAxioms.length === 0) {
+    await maic.seed(keyring);
+  }
+  const himId = opts.himId ?? "him.cli.default";
+  let him;
+  const existingHim = await maic.getHimRecord(himId);
+  if (existingHim) {
+    him = HimHandle.mint(
+      existingHim.birthSignature,
+      // We re-sign because we don't persist the original CreatorSignature
+      // alongside the public HimRecord projection; the AxiomStore retains the
+      // canonical signed envelope on disk.
+      keyring.sign(existingHim.birthSignature, Date.now()),
+      maic.creatorPublicKey,
+      // Merge any HIM-emergent axioms ratified in prior sessions (Entry 7).
+      [...existingHim.axiomsSnapshot, ...existingHim.emergentAxioms]
+    );
+  } else {
+    const birthSig = BirthSignatureBuilder.now().withHimId(himId).withPrimaryArchetype(opts.archetype ?? "aries-sun").withNotes("CLI default HIM").build();
+    him = await createHim(maic, keyring, birthSig);
+  }
+  const nhe = new Nhe({
+    himHandle: him,
+    maicClient: maic,
+    llmAdapter: opts.llmAdapter,
+    storeDir: join(storeDir, "nhe", him.id)
+  });
+  return {
+    nhe,
+    maic,
+    him,
+    keyring,
+    storeDir,
+    freshInstall: !exists
+  };
+}
+async function pathExists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/output.ts
+var isTty = Boolean(process.stdout.isTTY);
+function wrap(code, s) {
+  return isTty ? `\x1B[${code}m${s}\x1B[0m` : s;
+}
+var fmt = {
+  user: (s) => wrap(36, s),
+  // cyan
+  assistant: (s) => wrap(32, s),
+  // green
+  warn: (s) => wrap(33, s),
+  // yellow
+  error: (s) => wrap(31, s),
+  // red
+  dim: (s) => wrap(2, s),
+  bold: (s) => wrap(1, s)
+};
+
+// src/cli/chat.ts
+var HELP = `
+Commands:
+  /sleep            run a sleep cycle and immediately consolidate
+  /wake             consolidate any pending sleep files
+  /recall <query>   search consolidated memories
+  /help             show this help
+  /exit | /quit     leave the chat
+Anything else is sent as a user prompt to the NHE.
+`.trim();
+async function startChat(nhe) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: process.stdout.isTTY ?? false
+  });
+  let redirectAttempt = 0;
+  let alive = true;
+  console.log(fmt.dim(`(connected to ${nhe.id})`));
+  console.log(fmt.dim(`(adapter: ${nhe.recentInteractionsBuffer.length === 0 ? "ready" : "warm"} \u2014 type /help for commands, /exit to quit)`));
+  console.log();
+  const prompt = () => fmt.user("you > ");
+  rl.setPrompt(prompt());
+  rl.prompt();
+  rl.on("line", (raw) => {
+    const line = raw.trim();
+    if (line.length === 0) {
+      rl.prompt();
+      return;
+    }
+    void handleLine(line).catch((err2) => {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      console.error(fmt.error(`${msg}`));
+    }).finally(() => {
+      if (alive) rl.prompt();
+    });
+  });
+  rl.on("close", () => {
+    if (alive) {
+      console.log();
+      console.log(fmt.dim("Bye."));
+    }
+  });
+  await new Promise((resolve) => rl.once("close", resolve));
+  async function handleLine(line) {
+    if (line.startsWith("/")) {
+      await handleCommand(line);
+      return;
+    }
+    await handleUserPrompt(line);
+  }
+  async function handleCommand(line) {
+    const [cmd, ...rest] = line.slice(1).split(/\s+/);
+    switch (cmd) {
+      case "exit":
+      case "quit":
+        alive = false;
+        rl.close();
+        return;
+      case "help":
+        console.log(fmt.dim(HELP));
+        return;
+      case "sleep": {
+        process.stdout.write(fmt.dim("\u2022 entering sleep ..."));
+        const result = await nhe.sleep({ kind: "explicit" });
+        console.log(fmt.dim(` wrote ${result.yamlPath}`));
+        const consol = await nhe.wake();
+        console.log(
+          fmt.dim(
+            `\u2022 wake: ${consol.memoriesWritten.length} memor${consol.memoriesWritten.length === 1 ? "y" : "ies"} persisted, ${consol.discarded} discarded`
+          )
+        );
+        return;
+      }
+      case "wake": {
+        const consol = await nhe.wake();
+        console.log(
+          fmt.dim(
+            `\u2022 wake: ${consol.memoriesWritten.length} memor${consol.memoriesWritten.length === 1 ? "y" : "ies"} persisted, ${consol.discarded} discarded`
+          )
+        );
+        return;
+      }
+      case "recall": {
+        const query = rest.join(" ").trim();
+        if (!query) {
+          console.log(fmt.warn("usage: /recall <query>"));
+          return;
+        }
+        const hits = await nhe.recall(query, { limit: 5 });
+        if (hits.length === 0) {
+          console.log(fmt.dim("(no matching memories)"));
+          return;
+        }
+        for (const m of hits) {
+          console.log(
+            `${fmt.bold(`[${m.classification}]`)} ${fmt.dim(m.consolidatedAt)}
+  ${m.insight}
+`
+          );
+        }
+        return;
+      }
+      default:
+        console.log(fmt.warn(`unknown command: /${cmd}. Try /help.`));
+    }
+  }
+  async function handleUserPrompt(text) {
+    const out = await nhe.respond({ userPrompt: text, redirectAttempt });
+    if (out.kind === "ok") {
+      console.log(fmt.assistant("nhe > ") + out.text);
+      redirectAttempt = 0;
+      return;
+    }
+    if (out.kind === "redirect") {
+      const r = out.redirect;
+      console.log(
+        fmt.warn(`(redirect ${r.attempt}/${r.maxAttempts}) `) + fmt.assistant("nhe > ") + out.text
+      );
+      redirectAttempt = r.attempt;
+      return;
+    }
+    console.log(fmt.error("(refused) ") + out.text);
+    redirectAttempt = 0;
+  }
+}
+
+// src/cli/mcp-tools.ts
+function ok(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function err(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }, null, 2) }],
+    isError: true
+  };
+}
+async function nheRespondHandler(nhe, input) {
+  try {
+    const reqInput = { userPrompt: input.userPrompt };
+    if (input.redirectAttempt !== void 0) reqInput.redirectAttempt = input.redirectAttempt;
+    if (input.jurisdiction !== void 0) reqInput.jurisdiction = input.jurisdiction;
+    const out = await nhe.respond(reqInput);
+    return ok({
+      kind: out.kind,
+      text: out.text,
+      refused: out.refused,
+      redirect: out.redirect ?? null,
+      preReviewVerdict: {
+        kind: out.preReviewVerdict.kind,
+        reasonSummary: out.preReviewVerdict.reasonSummary,
+        citedAxioms: out.preReviewVerdict.citedAxioms
+      },
+      postReviewVerdict: {
+        kind: out.postReviewVerdict.kind,
+        reasonSummary: out.postReviewVerdict.reasonSummary,
+        citedAxioms: out.postReviewVerdict.citedAxioms
+      },
+      tokens: out.tokens,
+      auditIds: out.auditIds
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+async function nheRecallHandler(nhe, input) {
+  const opts = {};
+  if (input.limit !== void 0) opts.limit = input.limit;
+  const hits = await nhe.recall(input.query, opts);
+  return ok({
+    count: hits.length,
+    memories: hits.map((m) => ({
+      id: m.id,
+      classification: m.classification,
+      teleologicalValue: m.teleologicalValue,
+      consolidatedAt: m.consolidatedAt,
+      insight: m.insight
+    }))
+  });
+}
+async function nheSleepHandler(nhe) {
+  const result = await nhe.sleep({ kind: "explicit", reason: "mcp-tool" });
+  const rem = result.record.phases.find((p) => p.phase === "REM");
+  const dreamCount = rem && rem.content.kind === "dreams" ? rem.content.dreams.length : 0;
+  return ok({
+    yamlPath: result.yamlPath,
+    durationMinutes: result.record.sleep.durationMinutes,
+    dreamCount,
+    tokensIn: result.tokensIn,
+    tokensOut: result.tokensOut
+  });
+}
+async function nheWakeHandler(nhe) {
+  const result = await nhe.wake();
+  return ok({
+    processedSleepFiles: result.processedSleepFiles,
+    memoriesWritten: result.memoriesWritten.length,
+    discarded: result.discarded,
+    classifications: result.memoriesWritten.map((m) => ({
+      id: m.id,
+      classification: m.classification,
+      teleologicalValue: m.teleologicalValue
+    }))
+  });
+}
+async function maicListAxiomsHandler(maic) {
+  const axioms = await maic.listAxioms();
+  return ok({
+    count: axioms.length,
+    axioms: axioms.map((a) => ({
+      id: a.id,
+      rank: a.rank,
+      statement: a.statement,
+      weight: a.weight,
+      flexibility: a.flexibility,
+      immutable: a.immutable
+    }))
+  });
+}
+async function maicListHimsHandler(maic) {
+  const hims = await maic.listHims();
+  return ok({
+    count: hims.length,
+    hims: hims.map((h) => ({
+      himId: h.himId,
+      primaryArchetype: h.birthSignature.primaryArchetype,
+      bornAt: h.birthSignature.bornAt,
+      axiomCount: h.axiomsSnapshot.length,
+      registeredAt: h.registeredAt
+    }))
+  });
+}
+
+// src/cli/mcp.ts
+var PKG_VERSION = "1.0.0-trinity";
+function buildMcpServer(nhe, maic) {
+  const server = new McpServer({
+    name: "@teleologyhi-sdk/nhe",
+    version: PKG_VERSION
+  });
+  server.registerTool(
+    "nhe_respond",
+    {
+      title: "Send a prompt to the NHE",
+      description: "Run a user prompt through the NHE's MAIC pre-review \u2192 LLM \u2192 MAIC post-review pipeline. Returns text plus the verdict kind and any redirect metadata.",
+      inputSchema: {
+        userPrompt: z.string().min(1),
+        redirectAttempt: z.number().int().nonnegative().optional(),
+        jurisdiction: z.string().optional()
+      }
+    },
+    async (args) => nheRespondHandler(nhe, args)
+  );
+  server.registerTool(
+    "nhe_recall",
+    {
+      title: "Recall consolidated memories",
+      description: "Keyword search over the NHE's temporal-lobe markdown memories (lasting + temporary classes).",
+      inputSchema: {
+        query: z.string().min(1),
+        limit: z.number().int().positive().max(50).optional()
+      }
+    },
+    async (args) => nheRecallHandler(nhe, args)
+  );
+  server.registerTool(
+    "nhe_sleep",
+    {
+      title: "Run one sleep cycle",
+      description: "Generate a N1\u2192REM sleep cycle, writing a dream YAML record. Does not consolidate; call nhe_wake afterwards."
+    },
+    async () => nheSleepHandler(nhe)
+  );
+  server.registerTool(
+    "nhe_wake",
+    {
+      title: "Consolidate pending dreams",
+      description: "Classify each REM dream and write temporal-lobe markdown for lasting + temporary memories. Idempotent."
+    },
+    async () => nheWakeHandler(nhe)
+  );
+  server.registerTool(
+    "maic_list_axioms",
+    {
+      title: "List MAIC axioms",
+      description: "Return the full axiom corpus held by MAIC."
+    },
+    async () => maicListAxiomsHandler(maic)
+  );
+  server.registerTool(
+    "maic_list_hims",
+    {
+      title: "List registered HIMs",
+      description: "Return all HIMs registered with MAIC and their birth signatures."
+    },
+    async () => maicListHimsHandler(maic)
+  );
+  return server;
+}
+async function runMcpStdio(nhe, maic) {
+  const server = buildMcpServer(nhe, maic);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/cli/index.ts
+var HELP_TEXT = `
+@teleologyhi-sdk/nhe \u2014 CLI
+
+Usage:
+  teleologyhi-nhe <command> [options]
+
+Commands:
+  chat                       start an interactive chat session (default)
+  mcp                        run as a Model Context Protocol stdio server
+  help                       show this help
+
+Options for chat / mcp:
+  --store-dir <path>         directory for MAIC/HIM/NHE state (default ./teleologyhi-store)
+  --adapter <name>           force adapter: anthropic | gemini | mistral | deepseek | grok | ollama
+  --model <name>             model id (adapter-specific)
+  --ollama-base-url <url>    Ollama base URL (default http://localhost:11434)
+  --archetype <id>           primary archetype for a fresh HIM (default aries-sun)
+  --him-id <id>              persistent HIM id (default him.cli.default)
+
+Environment (auto-selection order when --adapter is omitted):
+  ANTHROPIC_API_KEY   auto-selects AnthropicAdapter (claude-sonnet-4-6)
+  GEMINI_API_KEY      auto-selects GeminiAdapter (gemini-3.5-flash)
+  MISTRAL_API_KEY     auto-selects MistralAdapter (mistral-large-latest)
+  DEEPSEEK_API_KEY    auto-selects DeepSeekAdapter (deepseek-chat)
+  XAI_API_KEY         auto-selects GrokAdapter (grok-4)
+  (fallback)          auto-detects local Ollama at default port
+
+Examples:
+  teleologyhi-nhe chat
+  teleologyhi-nhe chat --adapter ollama --model qwen2.5:7b
+  teleologyhi-nhe chat --adapter gemini --model gemini-3.5-flash
+  teleologyhi-nhe chat --adapter mistral --model mistral-small-latest
+  teleologyhi-nhe chat --adapter deepseek --model deepseek-reasoner
+  teleologyhi-nhe chat --adapter grok --model grok-4-fast
+`.trim();
+async function runCli(argv) {
+  const parsed = parseArgs(argv);
+  switch (parsed.subcommand) {
+    case "chat":
+    case "":
+      return chatCommand(parsed);
+    case "mcp":
+      return mcpCommand(parsed);
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(HELP_TEXT);
+      return 0;
+    default:
+      console.error(fmt.error(`unknown command: ${parsed.subcommand}`));
+      console.error(HELP_TEXT);
+      return 2;
+  }
+}
+async function mcpCommand(args) {
+  const detect = {};
+  const adapterFlag = args.flags.adapter;
+  if (isAdapterName(adapterFlag)) {
+    detect.adapter = adapterFlag;
+  }
+  const modelFlag = args.flags.model;
+  if (modelFlag) detect.model = modelFlag;
+  const ollamaUrlFlag = args.flags["ollama-base-url"];
+  if (ollamaUrlFlag) detect.ollamaBaseUrl = ollamaUrlFlag;
+  let detected;
+  try {
+    detected = await detectAdapter(detect);
+  } catch (e) {
+    process.stderr.write(`${e instanceof Error ? e.message : String(e)}
+`);
+    return 1;
+  }
+  const result = await bootstrap({
+    llmAdapter: detected.adapter,
+    ...args.flags["store-dir"] ? { storeDir: args.flags["store-dir"] } : {},
+    ...args.flags["him-id"] ? { himId: args.flags["him-id"] } : {},
+    ...args.flags.archetype ? { archetype: args.flags.archetype } : {}
+  });
+  process.stderr.write(
+    `[@teleologyhi-sdk/nhe mcp] storeDir=${result.storeDir} him=${result.him.id} adapter=${detected.source}:${detected.model}
+`
+  );
+  await runMcpStdio(result.nhe, result.maic);
+  return 0;
+}
+async function chatCommand(args) {
+  const detect = {};
+  const adapterFlag = args.flags.adapter;
+  if (isAdapterName(adapterFlag)) {
+    detect.adapter = adapterFlag;
+  }
+  const modelFlag = args.flags.model;
+  if (modelFlag) detect.model = modelFlag;
+  const ollamaUrlFlag = args.flags["ollama-base-url"];
+  if (ollamaUrlFlag) detect.ollamaBaseUrl = ollamaUrlFlag;
+  let detected;
+  try {
+    detected = await detectAdapter(detect);
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    console.error(fmt.error(msg));
+    return 1;
+  }
+  const result = await bootstrap({
+    llmAdapter: detected.adapter,
+    ...args.flags["store-dir"] ? { storeDir: args.flags["store-dir"] } : {},
+    ...args.flags["him-id"] ? { himId: args.flags["him-id"] } : {},
+    ...args.flags.archetype ? { archetype: args.flags.archetype } : {}
+  });
+  if (result.freshInstall) {
+    console.log(fmt.dim(`\u2022 fresh setup at ${result.storeDir}`));
+    console.log(fmt.dim(`\u2022 Creator keyring saved to ${result.storeDir}/creator.pem`));
+    console.log(fmt.dim(`\u2022 MAIC seeded with 8 axioms; HIM "${result.him.id}" minted`));
+  } else {
+    console.log(fmt.dim(`\u2022 reopened ${result.storeDir} (HIM "${result.him.id}")`));
+  }
+  console.log(fmt.dim(`\u2022 adapter: ${detected.source}:${detected.model}`));
+  console.log();
+  await startChat(result.nhe);
+  return 0;
+}
+function parseArgs(argv) {
+  const subcommand = argv[0] ?? "";
+  const rest = argv.slice(1);
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const tok = rest[i];
+    if (tok.startsWith("--")) {
+      const name = tok.slice(2);
+      const next = rest[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        flags[name] = next;
+        i++;
+      } else {
+        flags[name] = "";
+      }
+    } else {
+      positional.push(tok);
+    }
+  }
+  return { subcommand, flags, positional };
+}
+var isMain = import.meta.url === `file://${process.argv[1] ?? ""}`;
+if (isMain) {
+  runCli(process.argv.slice(2)).then(
+    (code) => process.exit(code),
+    (err2) => {
+      console.error(err2);
+      process.exit(1);
+    }
+  );
+}
+
+export { runCli };
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map