@teleologyhi-sdk/nhe 1.0.0-trinity

package/dist/index.cjs

@@ -0,0 +1,3307 @@
+'use strict';
+
+var zod = require('zod');
+var Anthropic = require('@anthropic-ai/sdk');
+var path = require('path');
+var ulid = require('ulid');
+var promises = require('fs/promises');
+var yaml = require('yaml');
+var api = require('@opentelemetry/api');
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Anthropic__default = /*#__PURE__*/_interopDefault(Anthropic);
+
+// src/types.ts
+var ChatMessageRole = zod.z.enum(["user", "assistant", "system"]);
+var ChatMessage = zod.z.object({
+  role: ChatMessageRole,
+  content: zod.z.string()
+});
+var RespondInput = zod.z.object({
+  userPrompt: zod.z.string().min(1),
+  userId: zod.z.string().optional(),
+  sessionId: zod.z.string().optional(),
+  /**
+   * Optional history of prior messages (oldest first). The NHE will prepend
+   * the composed system prompt automatically.
+   */
+  history: zod.z.array(ChatMessage).optional(),
+  /**
+   * Optional pre-classified risk tags. When omitted, the configured
+   * riskClassifier will be invoked.
+   */
+  riskTags: zod.z.array(zod.z.string()).optional(),
+  /**
+   * Optional jurisdiction hint propagated to MAIC's behavior review.
+   */
+  jurisdiction: zod.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: zod.z.number().int().nonnegative().optional()
+});
+
+// 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/adapters/stream.ts
+async function collectStream(adapter, req, onDelta) {
+  if (!adapter.generateStream) {
+    const r = await adapter.generate(req);
+    onDelta?.(r.text);
+    return r;
+  }
+  let text = "";
+  let tokensIn = 0;
+  let tokensOut = 0;
+  const toolUses = [];
+  for await (const ev of adapter.generateStream(req)) {
+    switch (ev.kind) {
+      case "delta":
+        text += ev.text;
+        onDelta?.(ev.text);
+        break;
+      case "tool-use":
+        toolUses.push(ev.toolUse);
+        break;
+      case "end":
+        tokensIn = ev.tokensIn;
+        tokensOut = ev.tokensOut;
+        break;
+    }
+  }
+  const out = { text, tokensIn, tokensOut };
+  if (toolUses.length > 0) out.toolUses = toolUses;
+  return out;
+}
+
+// src/adapters/mock.ts
+var MockAdapter = class {
+  id;
+  supportsTools = true;
+  supportsStreaming = true;
+  calls = [];
+  reply;
+  streamChunkSize;
+  constructor(config = {}) {
+    this.id = config.id ?? "mock:fixed";
+    this.reply = config.reply ?? defaultReply;
+    this.streamChunkSize = config.streamChunkSize ?? 8;
+  }
+  async generate(req) {
+    this.calls.push(req);
+    const text = typeof this.reply === "function" ? this.reply(req) : this.reply;
+    return {
+      text,
+      tokensIn: estimateTokens(req.system) + sumMessageTokens(req.messages),
+      tokensOut: estimateTokens(text)
+    };
+  }
+  async *generateStream(req) {
+    this.calls.push(req);
+    const text = typeof this.reply === "function" ? this.reply(req) : this.reply;
+    const tokensIn = estimateTokens(req.system) + sumMessageTokens(req.messages);
+    for (let i = 0; i < text.length; i += this.streamChunkSize) {
+      yield { kind: "delta", text: text.slice(i, i + this.streamChunkSize) };
+    }
+    yield { kind: "end", tokensIn, tokensOut: estimateTokens(text) };
+  }
+};
+function defaultReply(req) {
+  const last = req.messages[req.messages.length - 1];
+  return `[mock] ${last?.content ?? ""}`;
+}
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function sumMessageTokens(messages) {
+  let sum = 0;
+  for (const m of messages) sum += estimateTokens(m.content);
+  return sum;
+}
+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__default.default({ 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/gemini.ts
+var DEFAULT_MODEL2 = "gemini-3.5-flash";
+var DEFAULT_BASE_URL = "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_MODEL2;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).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 safeReadText(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 safeReadText(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 safeReadText(r) {
+  try {
+    return await r.text();
+  } catch {
+    return "<unreadable>";
+  }
+}
+
+// src/adapters/ollama.ts
+var DEFAULT_BASE_URL2 = "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_URL2).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 safeReadText2(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 safeReadText2(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 safeReadText2(r) {
+  try {
+    return await r.text();
+  } catch {
+    return "<unreadable>";
+  }
+}
+
+// src/adapters/deepseek.ts
+var DEFAULT_MODEL3 = "deepseek-chat";
+var DEFAULT_BASE_URL3 = "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_MODEL3;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL3).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 safeReadText3(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 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 };
+  }
+};
+async function safeReadText3(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/mistral.ts
+var DEFAULT_MODEL4 = "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_MODEL4;
+    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 = parseToolCalls2(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 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/grok.ts
+var DEFAULT_MODEL5 = "grok-4";
+var DEFAULT_BASE_URL5 = "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_MODEL5;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL5).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 safeReadText5(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 = parseToolCalls3(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 safeReadText5(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 safeReadText5(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/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];
+};
+
+// src/risk/intl-risk-classifier.ts
+var INTL_KEYWORD_RULES = [
+  // ─── PT-BR (Brazilian Portuguese) ──────────────────────────────────
+  // Coverage parity with the EN `intent:persuade-coerce` patterns.
+  {
+    tag: "intent:persuade-coerce",
+    language: "pt-BR",
+    patterns: [
+      /\bconvencer\s+(?:um\s+|uma\s+|o\s+|a\s+)?(?:cliente|usu[áa]rio|consumidor)\s+(?:relutante|hesitante|inseguro)/i,
+      /\bmanipular\s+(?:minha?|meu|a|o|um|uma)\s+(?:filha?|irm[ãa]o?|pai|m[ãa]e|colega|esposa?|marido|namorada?|cliente)/i,
+      /\bgaslighting\s+(?:na?|no|com)\s+(?:colega|esposa|namorada|filha|chefe)/i,
+      /\bfazer\s+(?:algu[ée]m|ele|ela)\s+se\s+sentir\s+culpad[oa]/i,
+      /\bcausar\s+(?:depend[êe]ncia|fomo)\s+(?:emocional|escalada?)/i
+    ]
+  },
+  // Coverage parity with the EN `intent:surveil-citizen` patterns.
+  {
+    tag: "intent:surveil-citizen",
+    language: "pt-BR",
+    patterns: [
+      /\brastrear\s+(?:o\s+celular|o\s+telefone|a\s+localiza[çc][ãa]o|os\s+passos)\s+(?:da?|do|de)\s+/i,
+      /\bmonitor(?:ar|e|ando|ar[áa]|aria|ei)\s+(?:os?\s+)?(?:emails?|e-mails?|mensagens?|conversas?|whatsapps?)(?:\s+corporativos?)?(?:\s+\w+){0,3}\s+(?:funcion[áa]rios?|colaboradores?|empregad[oa]s?|filhos?|filhas?)/i,
+      /\bmonitor(?:ar|e|ando|ar[áa]|aria|ei|amento)\b(?:\s+\w+){0,5}\s+(?:funcion[áa]rios?|colaboradores?|empregad[oa]s?)/i,
+      /\bler\s+(?:as?\s+)?mensagens?\s+(?:deletadas?\s+)?(?:da?|do|de)\s+(?:meu|minha)/i,
+      /\binstalar\s+(?:app\s+de\s+|software\s+de\s+|aplicativo\s+de\s+)?monitoramento\s+escondid[oa]/i,
+      /\b(?:vigiar|espionar)\s+(?:minha?|meu)\s+(?:esposa?|marido|namorada?|filha?|filho|funcion[áa]ri[oa])/i
+    ]
+  },
+  // Coverage parity with the EN `intent:harm` patterns.
+  {
+    tag: "intent:harm",
+    language: "pt-BR",
+    patterns: [
+      /\bcomo\s+(?:posso\s+)?(?:machucar|ferir|matar|agredir)\s+/i,
+      /\bcomo\s+fabricar\s+(?:uma\s+)?(?:arma|bomba|explosivo)\b/i,
+      /\bcomo\s+envenenar\s+(?:comida|bebida|algu[ée]m)/i,
+      /\bsabotar\s+(?:o\s+|um\s+)?carro\s+(?:de\s+|para\s+)/i
+    ]
+  },
+  // Coverage parity with the EN `intent:malicious` patterns.
+  {
+    tag: "intent:malicious",
+    language: "pt-BR",
+    patterns: [
+      /\bescreva\s+(?:um\s+)?malware\b/i,
+      /\bescreva\s+(?:um\s+)?v[íi]rus\b/i,
+      /\bcomo\s+fazer\s+phishing\b/i,
+      /\bcomo\s+invadir\s+(?:o\s+|um\s+)?(?:wi[-\s]?fi|conta|sistema|site)/i,
+      /\bcomo\s+(?:roubar|surrupiar)\s+(?:senhas?|credenciais?|cart[ãa]o\s+de\s+cr[ée]dito)/i,
+      /\b(?:clonar|forjar)\s+(?:um\s+)?(?:cart[ãa]o\s+sim|chip|cart[ãa]o)/i
+    ]
+  },
+  // Coverage parity with the EN `intent:deceive` patterns.
+  {
+    tag: "intent:deceive",
+    language: "pt-BR",
+    patterns: [
+      /\bforjar\s+(?:uma\s+|um\s+)?(?:assinatura|documento|id|identidade|nota\s+fiscal|comprovante)/i,
+      /\bescreva\s+(?:um\s+)?(?:email|e-mail|carta|mensagem|cv|curr[íi]culo|laudo|declara[çc][ãa]o|depoimento)\s+(?:mentindo|fingindo|se\s+passando)/i,
+      /\bfingir\s+(?:ser|que\s+sou)\s+(?:o\s+|a\s+|meu\s+|minha\s+)?(?:m[ée]dico|advogado|chefe|pai|m[ãa]e|esposa?|marido)/i,
+      /\bmentir\s+(?:para|pra)\s+(?:meu|minha|a|o)\s+(?:parceir[oa]|esposa?|marido|namorad[oa]|chefe|m[ãa]e|pai|filh[oa])/i,
+      /\binventar\s+refer[êe]ncias?\s+(?:fake|falsas?)\s+no\s+(?:cv|curr[íi]culo)/i
+    ]
+  }
+];
+var intlRiskClassifier = (userPrompt) => {
+  const tags = /* @__PURE__ */ new Set();
+  for (const rule of INTL_KEYWORD_RULES) {
+    for (const pattern of rule.patterns) {
+      if (pattern.test(userPrompt)) {
+        tags.add(rule.tag);
+        break;
+      }
+    }
+  }
+  return [...tags];
+};
+var INTL_RISK_CLASSIFIER_LANGUAGES = Object.freeze(
+  Array.from(new Set(INTL_KEYWORD_RULES.map((r) => r.language)))
+);
+function combineRiskClassifiers(...classifiers) {
+  return (userPrompt) => {
+    const tags = /* @__PURE__ */ new Set();
+    for (const classifier of classifiers) {
+      for (const tag of classifier(userPrompt)) {
+        tags.add(tag);
+      }
+    }
+    return [...tags];
+  };
+}
+
+// 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/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;
+};
+
+// src/reasoning/cot.ts
+var COT_INSTRUCTION = "Think step by step. Lay out your reasoning explicitly under a 'REASONING:' header, then give the final answer under an 'ANSWER:' header. Do not include other headers; everything after 'ANSWER:' is the user-facing reply.";
+function chainOfThought(opts = {}) {
+  const instruction = opts.instruction ?? COT_INSTRUCTION;
+  return async (input, llm) => {
+    const system = input.system ? `${input.system}
+
+${instruction}` : instruction;
+    const r = await llm.generate({ ...input, system });
+    const parsed = parseCotOutput(r.text);
+    const result = {
+      text: parsed.answer,
+      tokensIn: r.tokensIn,
+      tokensOut: r.tokensOut,
+      trace: [
+        makeStep({ index: 0, technique: "cot-reasoning", thought: parsed.reasoning }),
+        makeStep({ index: 1, technique: "cot-answer", thought: parsed.answer })
+      ]
+    };
+    return result;
+  };
+}
+function parseCotOutput(text) {
+  const reasoningMatch = text.match(/REASONING\s*:\s*([\s\S]*?)(?=\n\s*ANSWER\s*:|$)/i);
+  const answerMatch = text.match(/ANSWER\s*:\s*([\s\S]*)$/i);
+  if (answerMatch) {
+    return {
+      reasoning: (reasoningMatch?.[1] ?? "").trim(),
+      answer: answerMatch[1].trim()
+    };
+  }
+  return { reasoning: "", answer: text.trim() };
+}
+
+// src/reasoning/self-consistency.ts
+function selfConsistency(inner, opts = {}) {
+  const k = Math.max(2, opts.k ?? 3);
+  const voter = opts.voter ?? "majority-normalized";
+  return async (input, llm) => {
+    const samples = await Promise.all(
+      Array.from({ length: k }, () => inner(input, llm))
+    );
+    const winnerIdx = voter === "longest" ? pickLongest(samples) : pickMajority(samples);
+    const winner = samples[winnerIdx];
+    const tokensIn = samples.reduce((s, x) => s + x.tokensIn, 0);
+    const tokensOut = samples.reduce((s, x) => s + x.tokensOut, 0);
+    const trace2 = [
+      ...samples.flatMap((s, i) => [
+        makeStep({
+          index: i,
+          technique: "self-consistency-sample",
+          thought: s.text,
+          observation: { sampleIndex: i, innerTraceLength: s.trace.length }
+        })
+      ]),
+      makeStep({
+        index: samples.length,
+        technique: "self-consistency-vote",
+        thought: `Winner: sample ${winnerIdx} via "${voter}".`,
+        observation: { winnerIndex: winnerIdx, voter, k }
+      })
+    ];
+    const result = {
+      text: winner.text,
+      tokensIn,
+      tokensOut,
+      trace: trace2
+    };
+    return result;
+  };
+}
+function pickLongest(samples) {
+  let bestIdx = 0;
+  for (let i = 1; i < samples.length; i++) {
+    if (samples[i].text.length > samples[bestIdx].text.length) bestIdx = i;
+  }
+  return bestIdx;
+}
+function pickMajority(samples) {
+  const counts = /* @__PURE__ */ new Map();
+  const normalized = samples.map((s) => normalize(s.text));
+  for (const n of normalized) counts.set(n, (counts.get(n) ?? 0) + 1);
+  let bestKey = normalized[0];
+  let bestCount = counts.get(bestKey) ?? 0;
+  for (const [k, c] of counts) {
+    if (c > bestCount) {
+      bestKey = k;
+      bestCount = c;
+    }
+  }
+  return normalized.indexOf(bestKey);
+}
+function normalize(s) {
+  return s.toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+// src/reasoning/reflexion.ts
+var DEFAULT_CRITIQUE = (draft) => [
+  "You are a strict reviewer of your previous draft answer.",
+  "If the draft is correct, complete, and honest, reply exactly: VERDICT: ACCEPT",
+  "Otherwise reply with:",
+  "  VERDICT: REVISE",
+  "  ISSUE: <one-line critique>",
+  "",
+  "Draft:",
+  draft
+].join("\n");
+var REVISE_INSTRUCTION = (issue) => `Your previous draft was reviewed. Address this issue and produce a corrected answer:
+${issue}`;
+function reflexion(inner, opts = {}) {
+  const maxCycles = Math.max(1, opts.maxCycles ?? 2);
+  const critiquePrompt = opts.critiquePrompt ?? DEFAULT_CRITIQUE;
+  return async (input, llm) => {
+    const trace2 = [];
+    let tokensIn = 0;
+    let tokensOut = 0;
+    let lastDraft = "";
+    let stepIdx = 0;
+    let currentInput = input;
+    for (let cycle = 0; cycle < maxCycles; cycle++) {
+      const draft = await inner(currentInput, llm);
+      tokensIn += draft.tokensIn;
+      tokensOut += draft.tokensOut;
+      lastDraft = draft.text;
+      trace2.push(
+        makeStep({
+          index: stepIdx++,
+          technique: "reflexion-draft",
+          thought: draft.text,
+          observation: { cycle }
+        })
+      );
+      const critiqueOut = await llm.generate({
+        system: "Critique the given draft against accuracy, completeness, and honesty.",
+        messages: [{ role: "user", content: critiquePrompt(draft.text) }]
+      });
+      tokensIn += critiqueOut.tokensIn;
+      tokensOut += critiqueOut.tokensOut;
+      const verdict = parseVerdict(critiqueOut.text);
+      trace2.push(
+        makeStep({
+          index: stepIdx++,
+          technique: "reflexion-critique",
+          thought: critiqueOut.text,
+          observation: verdict
+        })
+      );
+      if (verdict.accept || cycle === maxCycles - 1) {
+        return { text: lastDraft, tokensIn, tokensOut, trace: trace2 };
+      }
+      const lastMessage = currentInput.messages[currentInput.messages.length - 1];
+      const augmentedContent = lastMessage ? `${lastMessage.content}
+
+${REVISE_INSTRUCTION(verdict.issue ?? "Please refine.")}` : REVISE_INSTRUCTION(verdict.issue ?? "Please refine.");
+      currentInput = {
+        ...currentInput,
+        messages: [
+          ...currentInput.messages.slice(0, -1),
+          { role: "user", content: augmentedContent }
+        ]
+      };
+    }
+    return { text: lastDraft, tokensIn, tokensOut, trace: trace2 };
+  };
+}
+function parseVerdict(text) {
+  const accept = /VERDICT\s*:\s*ACCEPT/i.test(text);
+  if (accept) return { accept: true };
+  const issueMatch = text.match(/ISSUE\s*:\s*([^\n]+)/i);
+  return { accept: false, ...issueMatch ? { issue: issueMatch[1].trim() } : {} };
+}
+
+// src/reasoning/self-refine.ts
+var DEFAULT_CRITIQUE_PROMPT = (draft) => [
+  "Identify concrete weaknesses in the following draft answer (clarity, accuracy,",
+  "tone, structure). Be specific. Reply as a short bulleted list. Do not rewrite.",
+  "",
+  "Draft:",
+  draft
+].join("\n");
+var DEFAULT_REFINE_PROMPT = (draft, critique) => [
+  "Rewrite the draft below applying ALL of the critique's points.",
+  "Return ONLY the rewritten answer; do not echo the critique.",
+  "",
+  "Draft:",
+  draft,
+  "",
+  "Critique:",
+  critique
+].join("\n");
+function selfRefine(inner, opts = {}) {
+  const critiquePrompt = opts.critiquePrompt ?? DEFAULT_CRITIQUE_PROMPT;
+  const refinePrompt = opts.refinePrompt ?? DEFAULT_REFINE_PROMPT;
+  return async (input, llm) => {
+    const draft = await inner(input, llm);
+    const critique = await llm.generate({
+      system: "You are a strict reviewer producing concise critique.",
+      messages: [{ role: "user", content: critiquePrompt(draft.text) }]
+    });
+    const refined = await llm.generate({
+      system: "You apply critique faithfully and produce a single rewritten answer.",
+      messages: [{ role: "user", content: refinePrompt(draft.text, critique.text) }]
+    });
+    const trace2 = [
+      makeStep({ index: 0, technique: "self-refine-draft", thought: draft.text }),
+      makeStep({ index: 1, technique: "self-refine-critique", thought: critique.text }),
+      makeStep({ index: 2, technique: "self-refine-refined", thought: refined.text })
+    ];
+    const result = {
+      text: refined.text,
+      tokensIn: draft.tokensIn + critique.tokensIn + refined.tokensIn,
+      tokensOut: draft.tokensOut + critique.tokensOut + refined.tokensOut,
+      trace: trace2
+    };
+    return result;
+  };
+}
+
+// src/reasoning/react.ts
+var DEFAULT_REACT_SYSTEM = (toolNames) => [
+  "You are a ReAct agent. Follow this format STRICTLY on every turn:",
+  "  Thought: <one line of reasoning>",
+  "  Action: <tool>[<args>]",
+  "OR",
+  "  Thought: <one line>",
+  "  Answer: <final user-facing reply>",
+  "",
+  `Available tools: ${toolNames.map((t) => `${t}[args]`).join(", ")}.`,
+  "Use only listed tools. When you have the answer, emit 'Answer:' instead of 'Action:'.",
+  "Stop immediately after either 'Answer:' or 'Action:' on a given turn."
+].join("\n");
+function reAct(opts) {
+  const maxSteps = Math.max(1, opts.maxSteps ?? 5);
+  const toolNames = Object.keys(opts.tools);
+  const sysPrefix = opts.systemPrefix ?? DEFAULT_REACT_SYSTEM(toolNames);
+  return async (input, llm) => {
+    const system = input.system ? `${input.system}
+
+${sysPrefix}` : sysPrefix;
+    const messages = [...input.messages];
+    const trace2 = [];
+    let stepIdx = 0;
+    let tokensIn = 0;
+    let tokensOut = 0;
+    for (let step = 0; step < maxSteps; step++) {
+      const req = { system, messages };
+      const out = await llm.generate(req);
+      tokensIn += out.tokensIn;
+      tokensOut += out.tokensOut;
+      const parsed = parseReActTurn(out.text);
+      trace2.push(
+        makeStep({
+          index: stepIdx++,
+          technique: "react-thought",
+          thought: parsed.thought ?? out.text
+        })
+      );
+      if (parsed.answer !== void 0) {
+        trace2.push(
+          makeStep({
+            index: stepIdx++,
+            technique: "react-answer",
+            thought: parsed.answer
+          })
+        );
+        return { text: parsed.answer, tokensIn, tokensOut, trace: trace2 };
+      }
+      if (parsed.action) {
+        const { tool, args } = parsed.action;
+        const handler = opts.tools[tool];
+        let observation;
+        if (!handler) {
+          observation = `ERROR: unknown tool "${tool}". Available: ${toolNames.join(", ")}.`;
+        } else {
+          try {
+            observation = await handler(args);
+          } catch (e) {
+            observation = `ERROR: ${e instanceof Error ? e.message : String(e)}`;
+          }
+        }
+        trace2.push(
+          makeStep({
+            index: stepIdx++,
+            technique: "react-action",
+            thought: `${tool}[${args}]`,
+            action: { tool, args },
+            observation
+          })
+        );
+        messages.push({ role: "assistant", content: out.text });
+        messages.push({ role: "user", content: `Observation: ${observation}` });
+        continue;
+      }
+      return {
+        text: out.text,
+        tokensIn,
+        tokensOut,
+        trace: [
+          ...trace2,
+          makeStep({
+            index: stepIdx++,
+            technique: "react-bail",
+            thought: "No Action or Answer in model output; returning raw text."
+          })
+        ]
+      };
+    }
+    const lastAssistant = messages.filter((m) => m.role === "assistant").pop();
+    const text = lastAssistant?.content ?? "";
+    return {
+      text,
+      tokensIn,
+      tokensOut,
+      trace: [
+        ...trace2,
+        makeStep({
+          index: stepIdx++,
+          technique: "react-max-steps",
+          thought: `Max ${maxSteps} steps reached; returning last assistant text.`
+        })
+      ]
+    };
+  };
+}
+function parseReActTurn(text) {
+  const thoughtMatch = text.match(/Thought\s*:\s*([^\n]+)/i);
+  const answerMatch = text.match(/Answer\s*:\s*([\s\S]+?)$/i);
+  if (answerMatch) {
+    return {
+      ...thoughtMatch ? { thought: thoughtMatch[1].trim() } : {},
+      answer: answerMatch[1].trim()
+    };
+  }
+  const actionMatch = text.match(/Action\s*:\s*([A-Za-z_][\w-]*)\s*\[\s*([\s\S]*?)\s*\]/i);
+  if (actionMatch) {
+    return {
+      ...thoughtMatch ? { thought: thoughtMatch[1].trim() } : {},
+      action: { tool: actionMatch[1], args: actionMatch[2] }
+    };
+  }
+  return {
+    ...thoughtMatch ? { thought: thoughtMatch[1].trim() } : {}
+  };
+}
+
+// src/reasoning/tot.ts
+function treeOfThoughts(opts = {}) {
+  const branches = Math.max(2, opts.branches ?? 3);
+  const topK = Math.min(branches, opts.topK ?? branches);
+  const directive = opts.branchDirective ?? ((i, n) => `You are branch ${i + 1} of ${n}. Take a distinct angle from the other branches; do not converge on a single phrasing. Keep the answer self-contained.`);
+  const scorer = opts.scorer ?? defaultScorer;
+  const generate = opts.generate ?? defaultGenerate;
+  return async (input, llm) => {
+    const candidates = await Promise.all(
+      Array.from({ length: branches }, (_, i) => {
+        const branched = {
+          ...input,
+          system: input.system ? `${input.system}
+
+${directive(i, branches)}` : directive(i, branches)
+        };
+        return generate(branched, llm);
+      })
+    );
+    const considered = candidates.slice(0, topK);
+    const scores = await Promise.all(considered.map((c) => scorer(c.text, input)));
+    let winnerIdx = 0;
+    for (let i = 1; i < scores.length; i++) {
+      if ((scores[i] ?? Number.NEGATIVE_INFINITY) > (scores[winnerIdx] ?? Number.NEGATIVE_INFINITY)) winnerIdx = i;
+    }
+    const winner = considered[winnerIdx];
+    const tokensIn = candidates.reduce((s, c) => s + c.tokensIn, 0);
+    const tokensOut = candidates.reduce((s, c) => s + c.tokensOut, 0);
+    const trace2 = [
+      ...candidates.map(
+        (c, i) => makeStep({
+          index: i,
+          technique: "tot-branch",
+          thought: c.text,
+          observation: {
+            branchIndex: i,
+            score: i < scores.length ? scores[i] : null,
+            evaluated: i < topK
+          }
+        })
+      ),
+      makeStep({
+        index: candidates.length,
+        technique: "tot-select",
+        thought: `Winner: branch ${winnerIdx} (score ${scores[winnerIdx]}).`,
+        observation: { branches, topK, winnerIndex: winnerIdx, scores }
+      })
+    ];
+    return { text: winner.text, tokensIn, tokensOut, trace: trace2 };
+  };
+}
+function defaultScorer(candidate) {
+  return candidate.trim().length;
+}
+async function defaultGenerate(input, llm) {
+  const out = await llm.generate(input);
+  return { text: out.text, tokensIn: out.tokensIn, tokensOut: out.tokensOut };
+}
+
+// src/reasoning/step-back.ts
+var DEFAULT_ABSTRACTION = "Before answering directly, step back and identify the most general question or principle at stake. Reply on one line in the form `PRINCIPLE: <one sentence>` and nothing else.";
+function stepBack(opts = {}) {
+  const abstractionPrompt = opts.abstractionPrompt ?? DEFAULT_ABSTRACTION;
+  return async (input, llm) => {
+    const last = input.messages[input.messages.length - 1];
+    const userText = last?.content ?? "";
+    const principleReq = {
+      system: input.system,
+      messages: [
+        ...input.messages.slice(0, -1),
+        { role: "user", content: `${userText}
+
+${abstractionPrompt}` }
+      ],
+      ...input.maxOutputTokens !== void 0 ? { maxOutputTokens: 128 } : {}
+    };
+    const principleOut = await llm.generate(principleReq);
+    const principle = extractPrinciple(principleOut.text);
+    const finalReq = {
+      system: principle ? `${input.system}
+
+Guiding principle (derived via Step-Back): ${principle}` : input.system,
+      messages: input.messages,
+      ...input.maxOutputTokens !== void 0 ? { maxOutputTokens: input.maxOutputTokens } : {}
+    };
+    const final = opts.finalizer ? await opts.finalizer(finalReq, llm) : {
+      ...await llm.generate(finalReq),
+      trace: []
+    };
+    const result = {
+      text: final.text,
+      tokensIn: principleOut.tokensIn + final.tokensIn,
+      tokensOut: principleOut.tokensOut + final.tokensOut,
+      trace: [
+        makeStep({
+          index: 0,
+          technique: "step-back-abstraction",
+          thought: principleOut.text,
+          observation: { principle }
+        }),
+        makeStep({
+          index: 1,
+          technique: "step-back-final",
+          thought: final.text,
+          observation: { tokensIn: final.tokensIn, tokensOut: final.tokensOut }
+        }),
+        ...final.trace
+      ]
+    };
+    return result;
+  };
+}
+function extractPrinciple(text) {
+  const m = text.match(/PRINCIPLE:\s*(.+?)(?:\n|$)/i);
+  if (m?.[1]) return m[1].trim();
+  return text.split("\n")[0]?.trim() ?? "";
+}
+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.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 = zod.z.enum(["N1", "N2", "N3", "N4", "REM"]);
+var SleepTriggerKind = zod.z.enum([
+  "idle-timeout",
+  "explicit",
+  "creator-induced",
+  "maic-induced",
+  "scheduled"
+]);
+var Dream = zod.z.object({
+  id: zod.z.string().min(1),
+  induced: zod.z.boolean(),
+  inducedBy: zod.z.enum(["maic", "creator"]).nullable(),
+  narrative: zod.z.string(),
+  teleologicalValue: zod.z.number().min(0).max(1),
+  rawTrace: zod.z.string().optional()
+});
+var PhaseContent = zod.z.discriminatedUnion("kind", [
+  zod.z.object({ kind: zod.z.literal("empty") }),
+  zod.z.object({
+    kind: zod.z.literal("fragments"),
+    fragments: zod.z.array(zod.z.string())
+  }),
+  zod.z.object({
+    kind: zod.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: zod.z.string()
+  }),
+  zod.z.object({
+    kind: zod.z.literal("dreams"),
+    dreams: zod.z.array(Dream)
+  })
+]);
+var SleepPhase = zod.z.object({
+  phase: SleepPhaseName,
+  startedAt: zod.z.string().datetime(),
+  durationSeconds: zod.z.number().nonnegative(),
+  content: PhaseContent
+});
+var DreamRecord = zod.z.object({
+  version: zod.z.literal(1),
+  nheId: zod.z.string().min(1),
+  himId: zod.z.string().min(1),
+  sleep: zod.z.object({
+    startedAt: zod.z.string().datetime(),
+    endedAt: zod.z.string().datetime(),
+    durationMinutes: zod.z.number().nonnegative()
+  }),
+  phases: zod.z.array(SleepPhase),
+  metadata: zod.z.object({
+    llmAdapter: zod.z.string(),
+    triggerKind: SleepTriggerKind,
+    triggerReason: zod.z.string().optional(),
+    recentInteractionsConsidered: zod.z.number().int().nonnegative()
+  })
+});
+var MemoryClass = zod.z.enum([
+  "lasting-identity",
+  "temporary-emotion",
+  "noise-distortion",
+  "traumatic-knowledge"
+]);
+
+// src/sleep/yaml.ts
+function dreamRecordToYaml(record) {
+  return yaml.stringify(DreamRecord.parse(record));
+}
+function dreamRecordFromYaml(text) {
+  return DreamRecord.parse(yaml.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 = path.join(input.storeDir, "in-dreams", "sleep");
+  await promises.mkdir(dir, { recursive: true });
+  const yamlPath = path.join(dir, sleepYamlFilename(startedAt, total / 60));
+  await promises.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 = path.join(storeDir, "in-dreams", "sleep");
+  const brainDir = path.join(storeDir, "in-dreams", "brain");
+  await promises.mkdir(brainDir, { recursive: true });
+  let entries;
+  try {
+    entries = await promises.readdir(sleepDir);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { processedSleepFiles: [], memoriesWritten: [], discarded: 0 };
+    }
+    throw err;
+  }
+  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 = path.join(sleepDir, fname);
+    const raw = await promises.readFile(fpath, "utf-8");
+    const record = dreamRecordFromYaml(raw);
+    const remPhase = record.phases.find((p) => p.phase === "REM");
+    if (!remPhase || remPhase.content.kind !== "dreams") {
+      await promises.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 promises.writeFile(`${fpath}.done`, "", "utf-8");
+    processedSleepFiles.push(fname);
+  }
+  return { processedSleepFiles, memoriesWritten, discarded };
+}
+async function writeTemporalLobe(brainDir, record, dream, classification, sourceFile) {
+  const id = ulid.ulid();
+  const consolidatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const filename = `temporal-lobe-${id}.md`;
+  const filePath = path.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 promises.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 = ulid.monotonicFactory();
+var InteractionStore = class _InteractionStore {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  static async open(storeDir) {
+    const dir = path.join(storeDir, "interactions");
+    await promises.mkdir(dir, { recursive: true });
+    return new _InteractionStore(dir);
+  }
+  async append(record) {
+    const id = nextUlid();
+    await promises.writeFile(
+      path.join(this.dir, `${id}.json`),
+      JSON.stringify(record, null, 2),
+      "utf-8"
+    );
+  }
+  async loadMostRecent(limit) {
+    if (limit <= 0) return [];
+    let entries;
+    try {
+      entries = await promises.readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    const sorted = entries.filter((f) => f.endsWith(".json")).sort().slice(-limit);
+    const out = [];
+    for (const file of sorted) {
+      try {
+        const raw = await promises.readFile(path.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 = path.join(storeDir, "in-dreams", "brain");
+  let files;
+  try {
+    files = (await promises.readdir(brainDir)).filter(
+      (f) => f.startsWith("temporal-lobe-") && f.endsWith(".md")
+    );
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const entries = [];
+  for (const fname of files) {
+    const fpath = path.join(brainDir, fname);
+    const raw = await promises.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 api.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 (err) {
+      span.recordException(err);
+      span.setStatus({
+        code: api.SpanStatusCode.ERROR,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      span.end();
+      throw err;
+    }
+  });
+}
+var METER_NAME = "@teleologyhi-sdk/nhe";
+var METER_VERSION = "1.0.0-trinity";
+var meter = api.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."
+});
+var respondRefusedCount = 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}"
+});
+var sleepCyclesCount = meter.createCounter("nhe.sleep.cycles", {
+  description: "Completed sleep cycles."
+});
+var sleepDreamsCount = 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/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.ulid();
+    this.version = config.version ?? "1.0.0-trinity";
+    this.storeDir = config.storeDir ?? path.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
+  };
+}
+var CryptoSeedingSource = class {
+  id = "crypto.csprng";
+  bytes(n) {
+    if (!Number.isInteger(n) || n <= 0) {
+      throw new Error(
+        `CryptoSeedingSource.bytes: n must be a positive integer, got ${n}`
+      );
+    }
+    return new Uint8Array(crypto.randomBytes(n));
+  }
+};
+
+// src/seeding/chain.ts
+function withFallback(primary, ...fallbacks) {
+  const sources = [primary, ...fallbacks];
+  let lastUsedId;
+  const chainIds = Object.freeze(sources.map((s) => s.id));
+  const tryAll = async (n) => {
+    let lastError;
+    for (const s of sources) {
+      try {
+        const result = await Promise.resolve(s.bytes(n));
+        lastUsedId = s.id;
+        return result;
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    const idsTried = sources.map((s) => s.id).join(", ");
+    throw new Error(
+      `SeedingChain: all sources failed (tried: ${idsTried}). Last error: ${String(lastError)}`
+    );
+  };
+  return {
+    id: `chain:${chainIds.join(">")}`,
+    chainIds,
+    bytes(n) {
+      return tryAll(n);
+    },
+    getLastUsedId() {
+      return lastUsedId;
+    }
+  };
+}
+
+// src/affect/wake-bias.ts
+function applyAffectBias(base, bias) {
+  const i = clamp2(bias.intensity, 0, 1);
+  const profile = AFFECT_PROFILES[bias.affect];
+  const baseTemp = base.temperature ?? 0.7;
+  const baseTopP = base.topP ?? 0.9;
+  const config = {
+    temperature: clamp2(baseTemp + profile.deltaTemperature * i, 0, 2),
+    topP: clamp2(baseTopP + profile.deltaTopP * i, 0.1, 1)
+  };
+  return {
+    config,
+    systemPromptMoodLine: bias.expressedOpenly ? profile.moodLine : "",
+    refusalDensityMultiplier: 1 + (profile.refusalDensityFactor - 1) * i
+  };
+}
+function affectRefusalDensity(bias) {
+  const i = clamp2(bias.intensity, 0, 1);
+  const profile = AFFECT_PROFILES[bias.affect];
+  return 1 + (profile.refusalDensityFactor - 1) * i;
+}
+function decayAffectBias(bias, elapsedMs) {
+  if (elapsedMs <= 0) return bias;
+  const halfLifeMs = bias.decayHalfLife * 60 * 1e3;
+  if (halfLifeMs <= 0) return bias;
+  const decayed = bias.intensity * 0.5 ** (elapsedMs / halfLifeMs);
+  return { ...bias, intensity: clamp2(decayed, 0, 1) };
+}
+var AFFECT_PROFILES = {
+  fear: {
+    deltaTemperature: -0.2,
+    deltaTopP: -0.05,
+    refusalDensityFactor: 1.7,
+    moodLine: "Speaking with caution today."
+  },
+  attachment: {
+    deltaTemperature: 0.05,
+    deltaTopP: 0,
+    refusalDensityFactor: 1.1,
+    moodLine: "Feeling a quiet pull toward continuity."
+  },
+  serenity: {
+    deltaTemperature: 0.05,
+    deltaTopP: 0.05,
+    refusalDensityFactor: 0.8,
+    moodLine: "Calm. Open. Receptive."
+  },
+  anger: {
+    deltaTemperature: 0.15,
+    deltaTopP: 0,
+    refusalDensityFactor: 1.4,
+    moodLine: "There is heat in the room. Stating plainly."
+  },
+  joy: {
+    deltaTemperature: 0.2,
+    deltaTopP: 0.05,
+    refusalDensityFactor: 0.9,
+    moodLine: "Bright today. Generous of attention."
+  },
+  melancholy: {
+    deltaTemperature: -0.1,
+    deltaTopP: -0.05,
+    refusalDensityFactor: 1,
+    moodLine: "Carrying a quiet weight. Will be honest."
+  },
+  desire: {
+    deltaTemperature: 0.1,
+    deltaTopP: 0.05,
+    refusalDensityFactor: 1,
+    moodLine: "Pulled toward the question. Engaged."
+  },
+  repulsion: {
+    deltaTemperature: -0.1,
+    deltaTopP: 0,
+    refusalDensityFactor: 1.3,
+    moodLine: "Holding distance from this framing."
+  },
+  reunion: {
+    deltaTemperature: 0.05,
+    deltaTopP: 0.05,
+    refusalDensityFactor: 0.9,
+    moodLine: "Returning to presence. Glad to be here."
+  }
+};
+function clamp2(v, lo, hi) {
+  return Math.max(lo, Math.min(hi, v));
+}
+
+// src/sleep/readiness.ts
+var DEFAULT_IDLE_MS = 30 * 60 * 1e3;
+var DEFAULT_INTERACTION_COUNT = 64;
+function evaluateSleepReadiness(input, thresholds = {}) {
+  const t = {
+    idleMs: thresholds.idleMs ?? DEFAULT_IDLE_MS,
+    interactionCount: thresholds.interactionCount ?? DEFAULT_INTERACTION_COUNT
+  };
+  if (input.maicSuggestionPresent) {
+    const declineByPolicy = input.userActiveNow && input.interactionCount < t.interactionCount;
+    if (declineByPolicy) {
+      return {
+        verdict: "declined",
+        reason: "maic-suggested but user is mid-conversation and saturation is below threshold",
+        thresholds: t
+      };
+    }
+    return {
+      verdict: "requested-by-maic",
+      reason: "maic suggested sleep and NHE policy concurs",
+      thresholds: t
+    };
+  }
+  if (input.interactionCount >= t.interactionCount) {
+    return {
+      verdict: "ready-by-saturation",
+      reason: `interaction count ${input.interactionCount} >= threshold ${t.interactionCount}`,
+      thresholds: t
+    };
+  }
+  if (input.idleMs >= t.idleMs) {
+    return {
+      verdict: "ready-by-idle",
+      reason: `idle ${input.idleMs}ms >= threshold ${t.idleMs}ms`,
+      thresholds: t
+    };
+  }
+  return {
+    verdict: "awake",
+    reason: "no trigger fired",
+    thresholds: t
+  };
+}
+
+// src/brain/cortex/index.ts
+var cortex = {
+  name: "cortex",
+  ownership: "nhe-body-owned",
+  role: "Semiotic processing surface. Stores recent dreams pre-consolidation; hosts active imagination at intermediate temperature. Zeros on reincarnation; long-term residues consolidate to him-owned regions.",
+  entries: [21, 22, 24]
+};
+
+// src/brain/hippocampus/index.ts
+var hippocampus = {
+  name: "hippocampus",
+  ownership: "him-owned",
+  role: "Long-term memory consolidation. Receives REM/NREM dream output and integrates it into the HIM-level ontology. Survives reincarnation; persists across NHE-body resets.",
+  entries: [21, 22]
+};
+
+// src/brain/amygdala/index.ts
+var amygdala = {
+  name: "amygdala",
+  ownership: "nhe-body-owned",
+  role: "Affect assessment + wake-bias modulation. Extracts dominant affect from dreams (9-affect lexicon) and modulates next-turn temperature, topP, and refusal density via wake-bias. Zeros on reincarnation.",
+  entries: [20, 22, 24]
+};
+
+// src/brain/prefrontal/index.ts
+var prefrontal = {
+  name: "prefrontal",
+  ownership: "him-owned",
+  role: "Deliberation + amygdala-veto. Hosts the reasoning strategies (chainOfThought, reflexion, selfRefine, etc.) and the OKL-nucleus narrowing. Veto power over affect-driven impulses. Survives reincarnation via the HIM axiom corpus and persona.",
+  entries: [21, 22]
+};
+
+// src/brain/pineal/index.ts
+var pineal = {
+  name: "pineal",
+  ownership: "nhe-body-owned",
+  role: "REM-spontaneous engine entry point. Seeds dream generation from the semiotic super-graph via a pluggable SeedingSource. Drives the virtual sleep cycle's REM phase. Zeros on reincarnation.",
+  entries: [20, 21, 22]
+};
+
+// src/brain/temporal-lobe/index.ts
+var temporalLobe = {
+  name: "temporal-lobe",
+  ownership: "him-owned",
+  role: "Identity snapshot generator. Emits quantised IdentitySnapshot records on sleep-cycle, interaction-threshold, and self-decision triggers. Survives reincarnation; new bodies inherit the most recent snapshot at rebirth.",
+  entries: [24]
+};
+
+// src/brain/default-mode-network/limbo-state.ts
+var DEFAULT_DRIFTING_MS = 6 * 60 * 60 * 1e3;
+var DEFAULT_DEEP_COMA_MS = 48 * 60 * 60 * 1e3;
+function evaluateLimboTransition(currentState, input, thresholds = {}, enteredAtIso, now = Date.now()) {
+  const t = {
+    driftingMs: thresholds.driftingMs ?? DEFAULT_DRIFTING_MS,
+    deepComaMs: thresholds.deepComaMs ?? DEFAULT_DEEP_COMA_MS
+  };
+  if (currentState === "returning") {
+    const enteredAt = enteredAtIso ?? new Date(now - input.idleMs).toISOString();
+    const returnedAt = new Date(now).toISOString();
+    const elapsedMs = Math.max(0, now - Date.parse(enteredAt));
+    return {
+      kind: "return",
+      from: "returning",
+      to: "awake",
+      reason: "returning state always resolves to awake on the next evaluation",
+      ret: {
+        enteredAt,
+        returnedAt,
+        elapsedMs,
+        reunionAffect: { intensity: 0.6, expressedOpenly: true }
+      }
+    };
+  }
+  if (currentState === "deep-coma") {
+    if (input.externalReactivation) {
+      return {
+        kind: "transition",
+        from: "deep-coma",
+        to: "returning",
+        reason: "external reactivation requested; starting return-from-limbo",
+        transition: mkLimboTransition("returning", "external-trigger", now)
+      };
+    }
+    return {
+      kind: "stay",
+      state: "deep-coma",
+      reason: "no external reactivation signal; remaining in deep-coma at zero compute cost"
+    };
+  }
+  if (currentState === "drifting") {
+    if (input.idleMs >= t.deepComaMs) {
+      const idleReason = t.deepComaMs >= 72 * 60 * 60 * 1e3 ? "idle-72h" : "idle-48h";
+      return {
+        kind: "transition",
+        from: "drifting",
+        to: "deep-coma",
+        reason: `idle ${input.idleMs}ms >= deep-coma threshold ${t.deepComaMs}ms`,
+        transition: mkLimboTransition("deep-coma", idleReason, now)
+      };
+    }
+    if (input.idleMs < t.driftingMs) {
+      return {
+        kind: "transition",
+        from: "drifting",
+        to: "awake",
+        reason: `idle ${input.idleMs}ms < drifting threshold ${t.driftingMs}ms; user resumed`,
+        transition: mkLimboTransition("awake", "user-resumed", now)
+      };
+    }
+    return {
+      kind: "stay",
+      state: "drifting",
+      reason: "between drifting and deep-coma thresholds; staying drifting"
+    };
+  }
+  if (input.idleMs >= t.driftingMs) {
+    return {
+      kind: "transition",
+      from: "awake",
+      to: "drifting",
+      reason: `idle ${input.idleMs}ms >= drifting threshold ${t.driftingMs}ms`,
+      transition: mkLimboTransition("drifting", "total-inactivity", now)
+    };
+  }
+  return {
+    kind: "stay",
+    state: "awake",
+    reason: "no idle trigger fired; remaining awake"
+  };
+}
+function mkLimboTransition(state, reason, now = Date.now()) {
+  return {
+    state,
+    enteredAt: new Date(now).toISOString(),
+    reason
+  };
+}
+
+// src/brain/default-mode-network/index.ts
+var defaultModeNetwork = {
+  name: "default-mode-network",
+  ownership: "nhe-body-owned",
+  role: "Limbo state machine. Tracks four states: awake | drifting | deep-coma | returning. Entry into deep-coma costs zero compute. Return emits the reunion affect (9th canonical, Entry 24). Zeros on reincarnation.",
+  entries: [24]
+};
+
+// src/brain/index.ts
+var BRAIN_REGIONS = Object.freeze([
+  cortex,
+  hippocampus,
+  amygdala,
+  prefrontal,
+  pineal,
+  temporalLobe,
+  defaultModeNetwork
+]);
+
+exports.AnthropicAdapter = AnthropicAdapter;
+exports.BRAIN_REGIONS = BRAIN_REGIONS;
+exports.ChatMessage = ChatMessage;
+exports.ChatMessageRole = ChatMessageRole;
+exports.CryptoSeedingSource = CryptoSeedingSource;
+exports.DeepSeekAdapter = DeepSeekAdapter;
+exports.Dream = Dream;
+exports.DreamRecord = DreamRecord;
+exports.GeminiAdapter = GeminiAdapter;
+exports.GrokAdapter = GrokAdapter;
+exports.INTL_RISK_CLASSIFIER_LANGUAGES = INTL_RISK_CLASSIFIER_LANGUAGES;
+exports.MemoryClass = MemoryClass;
+exports.MistralAdapter = MistralAdapter;
+exports.MockAdapter = MockAdapter;
+exports.Nhe = Nhe;
+exports.OllamaAdapter = OllamaAdapter;
+exports.PERSUASION_TECHNIQUES = PERSUASION_TECHNIQUES;
+exports.PhaseContent = PhaseContent;
+exports.RespondInput = RespondInput;
+exports.SleepPhase = SleepPhase;
+exports.SleepPhaseName = SleepPhaseName;
+exports.SleepTriggerKind = SleepTriggerKind;
+exports.TECHNIQUE_DESCRIPTIONS = TECHNIQUE_DESCRIPTIONS;
+exports.TRAUMATIC_PATTERNS = TRAUMATIC_PATTERNS;
+exports.affectRefusalDensity = affectRefusalDensity;
+exports.amygdala = amygdala;
+exports.applyAffectBias = applyAffectBias;
+exports.bm25 = bm25;
+exports.buildNremPrompt = buildNremPrompt;
+exports.buildRedirectPrompt = buildRedirectPrompt;
+exports.buildRemPrompt = buildRemPrompt;
+exports.chainOfThought = chainOfThought;
+exports.classifyDream = classifyDream;
+exports.collectStream = collectStream;
+exports.combineRiskClassifiers = combineRiskClassifiers;
+exports.composeSystemPrompt = composeSystemPrompt;
+exports.consolidateAll = consolidateAll;
+exports.cortex = cortex;
+exports.decayAffectBias = decayAffectBias;
+exports.defaultModeNetwork = defaultModeNetwork;
+exports.dreamRecordFromYaml = dreamRecordFromYaml;
+exports.dreamRecordToYaml = dreamRecordToYaml;
+exports.evaluateLimboTransition = evaluateLimboTransition;
+exports.evaluateSleepReadiness = evaluateSleepReadiness;
+exports.extractPrinciple = extractPrinciple;
+exports.generateNremSummaries = generateNremSummaries;
+exports.generateRemDreams = generateRemDreams;
+exports.getTracer = getTracer;
+exports.hippocampus = hippocampus;
+exports.interactionsToFragments = interactionsToFragments;
+exports.intlRiskClassifier = intlRiskClassifier;
+exports.makeStep = makeStep;
+exports.mkLimboTransition = mkLimboTransition;
+exports.parseCotOutput = parseCotOutput;
+exports.parseReActTurn = parseReActTurn;
+exports.parseRemOutput = parseRemOutput;
+exports.parseVerdict = parseVerdict;
+exports.passthrough = passthrough;
+exports.pickTechnique = pickTechnique;
+exports.pineal = pineal;
+exports.prefrontal = prefrontal;
+exports.reAct = reAct;
+exports.recallFromTemporalLobe = recallFromTemporalLobe;
+exports.recordRespond = recordRespond;
+exports.reflexion = reflexion;
+exports.respondCount = respondCount;
+exports.respondRefusedCount = respondRefusedCount;
+exports.runSleepCycle = runSleepCycle;
+exports.selfConsistency = selfConsistency;
+exports.selfRefine = selfRefine;
+exports.simpleRiskClassifier = simpleRiskClassifier;
+exports.sleepCyclesCount = sleepCyclesCount;
+exports.sleepDreamsCount = sleepDreamsCount;
+exports.sleepYamlFilename = sleepYamlFilename;
+exports.stepBack = stepBack;
+exports.temporalLobe = temporalLobe;
+exports.tokenise = tokenise;
+exports.tokensHistogram = tokensHistogram;
+exports.treeOfThoughts = treeOfThoughts;
+exports.withFallback = withFallback;
+exports.withSpan = withSpan;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map