omnius 1.0.698 → 1.0.699

package/dist/index.js

@@ -68841,7 +68841,7 @@ var init_playwright_browser = __esm({
               if (!["web_serial", "web_usb", "camera", "microphone"].includes(capability)) {
                 return fail("hardware_capability must be one of web_serial, web_usb, camera, or microphone", start2);
               }
-              const availability = await browserState().page.evaluate((requested) => {
+              const availability2 = await browserState().page.evaluate((requested) => {
                 const runtimeNavigator = navigator;
                 const hasApi = requested === "web_serial" ? Boolean(runtimeNavigator.serial) : requested === "web_usb" ? Boolean(runtimeNavigator.usb) : Boolean(runtimeNavigator.mediaDevices);
                 return {
@@ -68851,7 +68851,7 @@ var init_playwright_browser = __esm({
                 };
               }, capability);
               const prerequisite = capability === "web_serial" ? "a physical serial device plus a secure-context user gesture" : capability === "web_usb" ? "a physical USB device plus a secure-context user gesture" : `a granted ${capability} permission and a real capture device`;
-              const reason = availability.hasApi && availability.secureContext ? `${capability} API is exposed, but this session has not selected or been granted ${prerequisite}.` : `${capability} cannot be exercised: ${availability.hasApi ? "the page is not a secure context" : "the browser API is unavailable"}; it still requires ${prerequisite}.`;
+              const reason = availability2.hasApi && availability2.secureContext ? `${capability} API is exposed, but this session has not selected or been granted ${prerequisite}.` : `${capability} cannot be exercised: ${availability2.hasApi ? "the page is not a secure context" : "the browser API is unavailable"}; it still requires ${prerequisite}.`;
               const event = createEvidenceEvent({
                 sessionId: browserState().playwrightSessionId ?? void 0,
                 tool: "playwright_browser",
@@ -68867,9 +68867,9 @@ var init_playwright_browser = __esm({
                 },
                 metadata: {
                   capability,
-                  secureContext: availability.secureContext,
-                  browserApiAvailable: availability.hasApi,
-                  userActivation: availability.userActivation,
+                  secureContext: availability2.secureContext,
+                  browserApiAvailable: availability2.hasApi,
+                  userActivation: availability2.userActivation,
                   prerequisite
                 }
               });
@@ -68880,9 +68880,9 @@ var init_playwright_browser = __esm({
                   `capability=${capability}`,
                   "outcome=blocked",
                   `reason=${reason}`,
-                  `secure_context=${availability.secureContext}`,
-                  `browser_api_available=${availability.hasApi}`,
-                  `user_activation=${availability.userActivation}`,
+                  `secure_context=${availability2.secureContext}`,
+                  `browser_api_available=${availability2.hasApi}`,
+                  `user_activation=${availability2.userActivation}`,
                   `next=${event.verification?.nextSuggestedObservation}`
                 ].join("\n"),
                 evidenceEvents: [event],
@@ -74084,118 +74084,168 @@ var init_memoryGraph = __esm({
 });
 
 // packages/memory/dist/embeddings.js
+function canonicalModel(model) {
+  const name10 = model.trim();
+  return name10.slice(name10.lastIndexOf("/") + 1).includes(":") ? name10 : `${name10}:latest`;
+}
+function resolveConfig(config) {
+  const configuredModel = config?.model ?? (process.env["OMNIUS_EMBEDDING_MODEL"]?.trim() || process.env["EMBED_MODEL"]?.trim() || "nomic-embed-text");
+  const model = configuredModel.trim();
+  if (!model)
+    throw new Error("Embedding model must be nonempty");
+  const endpoint = new URL(config?.baseUrl ?? "http://localhost:11434");
+  endpoint.pathname = endpoint.pathname.replace(/\/+$/, "");
+  if (endpoint.search || endpoint.hash || !["http:", "https:"].includes(endpoint.protocol)) {
+    throw new Error("Invalid embedding endpoint");
+  }
+  const timeoutMs = config?.timeoutMs ?? 3e4;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0)
+    throw new Error("Invalid embedding timeout");
+  return { baseUrl: endpoint.toString().replace(/\/+$/, ""), model, timeoutMs, signal: config?.signal };
+}
 function embeddingRequestSignal(timeoutMs, external) {
   const timeout2 = AbortSignal.timeout(timeoutMs);
   return external ? AbortSignal.any([external, timeout2]) : timeout2;
 }
-async function generateEmbedding(text5, config) {
-  const cfg = { ...DEFAULT_CONFIG3, ...config };
-  if (cfg.signal?.aborted)
-    return null;
+function availabilityEntry(cfg) {
+  const key2 = JSON.stringify([cfg.baseUrl, canonicalModel(cfg.model)]);
+  let entry = availability.get(key2);
+  if (!entry) {
+    if (availability.size >= MAX_AVAILABILITY_ENTRIES)
+      availability.delete(availability.keys().next().value);
+    entry = { blockedUntil: 0, readyUntil: 0 };
+  }
+  availability.delete(key2);
+  availability.set(key2, entry);
+  return entry;
+}
+async function waitForAvailability(pending2, signal) {
+  signal.throwIfAborted();
+  let onAbort = () => {
+  };
   try {
-    const url = `${cfg.baseUrl}/api/embed`;
-    const resp = await fetch(url, {
+    await Promise.race([
+      pending2,
+      new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+    signal.throwIfAborted();
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+async function requestEmbeddings(texts, config, single) {
+  const unavailable = () => texts.map(() => null);
+  if (texts.length === 0 || config?.signal?.aborted)
+    return unavailable();
+  let finishDiscovery;
+  let entry;
+  try {
+    const cfg = resolveConfig(config);
+    const signal = embeddingRequestSignal(cfg.timeoutMs * (single ? 1 : 2), cfg.signal);
+    entry = availabilityEntry(cfg);
+    while (true) {
+      signal.throwIfAborted();
+      if (entry.blockedUntil > Date.now())
+        return unavailable();
+      if (entry.pending) {
+        await waitForAvailability(entry.pending, signal);
+        continue;
+      }
+      if (entry.readyUntil <= Date.now()) {
+        entry.pending = new Promise((resolve108) => {
+          finishDiscovery = resolve108;
+        });
+      }
+      break;
+    }
+    const resp = await fetch(`${cfg.baseUrl}/api/embed`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: cfg.model,
-        input: text5
-      }),
-      signal: embeddingRequestSignal(cfg.timeoutMs, cfg.signal)
+      body: JSON.stringify({ model: cfg.model, input: single ? texts[0] : texts }),
+      signal
     });
+    signal.throwIfAborted();
     if (!resp.ok) {
       if (resp.status === 404) {
-        const pulled = await pullEmbeddingModel(cfg.baseUrl, cfg.model, cfg.timeoutMs, cfg.signal);
-        if (!pulled)
-          return null;
-        return generateEmbedding(text5, config);
+        entry.blockedUntil = Date.now() + AVAILABILITY_TTL_MS;
+        entry.readyUntil = 0;
       }
-      return null;
+      await resp.body?.cancel();
+      return unavailable();
     }
     const data = await resp.json();
-    const rawVector = data.embeddings?.[0] ?? data.embedding;
-    if (!rawVector || rawVector.length === 0)
-      return null;
-    return {
-      vector: new Float32Array(rawVector),
-      model: cfg.model,
-      dimensions: rawVector.length
-    };
+    signal.throwIfAborted();
+    if (!data || typeof data !== "object")
+      return unavailable();
+    const payload = data;
+    const raw = payload.embeddings ?? (single && payload.embedding ? [payload.embedding] : void 0);
+    if (!Array.isArray(raw) || raw.length !== texts.length)
+      return unavailable();
+    const vectors = [];
+    for (const vector of raw) {
+      if (!Array.isArray(vector) || vector.length === 0 || vector.some((value2) => typeof value2 !== "number" || !Number.isFinite(value2)))
+        return unavailable();
+      const typed = new Float32Array(vector);
+      if (typed.some((value2) => !Number.isFinite(value2)) || !typed.some((value2) => value2 !== 0) || vectors[0] && typed.length !== vectors[0].length)
+        return unavailable();
+      vectors.push(typed);
+    }
+    entry.blockedUntil = 0;
+    entry.readyUntil = Date.now() + AVAILABILITY_TTL_MS;
+    return vectors.map((vector) => ({ vector, model: cfg.model, dimensions: vector.length }));
   } catch {
-    return null;
+    return unavailable();
+  } finally {
+    if (finishDiscovery) {
+      entry.pending = void 0;
+      finishDiscovery();
+    }
   }
 }
+async function generateEmbedding(text5, config) {
+  return (await requestEmbeddings([text5], config, true))[0] ?? null;
+}
 async function generateEmbeddingBatch(texts, config) {
-  const cfg = { ...DEFAULT_CONFIG3, ...config };
-  if (cfg.signal?.aborted)
-    return texts.map(() => null);
-  try {
-    const url = `${cfg.baseUrl}/api/embed`;
-    const resp = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: cfg.model,
-        input: texts
-      }),
-      signal: embeddingRequestSignal(cfg.timeoutMs * 2, cfg.signal)
-      // longer timeout for batch
-    });
-    if (!resp.ok)
-      return texts.map(() => null);
-    const data = await resp.json();
-    if (!data.embeddings)
-      return texts.map(() => null);
-    return data.embeddings.map((vec) => vec && vec.length > 0 ? {
-      vector: new Float32Array(vec),
-      model: cfg.model,
-      dimensions: vec.length
-    } : null);
-  } catch {
-    return texts.map(() => null);
-  }
+  return requestEmbeddings(texts, config, false);
 }
 async function checkEmbeddingAvailable(config) {
-  const cfg = { ...DEFAULT_CONFIG3, ...config };
-  if (cfg.signal?.aborted)
+  if (config?.signal?.aborted)
     return false;
   try {
-    const resp = await fetch(`${cfg.baseUrl}/api/tags`, {
-      signal: embeddingRequestSignal(5e3, cfg.signal)
-    });
-    if (!resp.ok)
+    const cfg = resolveConfig(config);
+    const signal = embeddingRequestSignal(5e3, cfg.signal);
+    const resp = await fetch(`${cfg.baseUrl}/api/tags`, { signal });
+    if (!resp.ok) {
+      await resp.body?.cancel();
       return false;
+    }
     const data = await resp.json();
-    return data.models?.some((m2) => m2.name.startsWith(cfg.model)) ?? false;
-  } catch {
-    return false;
-  }
-}
-async function pullEmbeddingModel(baseUrl3, model, timeoutMs, signal) {
-  if (signal?.aborted)
-    return false;
-  try {
-    const resp = await fetch(`${baseUrl3}/api/pull`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ name: model, stream: false }),
-      signal: embeddingRequestSignal(timeoutMs * 10, signal)
-      // pulling can take minutes
+    signal.throwIfAborted();
+    if (!data || typeof data !== "object")
+      return false;
+    const models = data.models;
+    if (!Array.isArray(models))
+      return false;
+    return models.some((item) => {
+      if (!item || typeof item !== "object")
+        return false;
+      const name10 = item.name;
+      return typeof name10 === "string" && canonicalModel(name10) === canonicalModel(cfg.model);
     });
-    return resp.ok;
   } catch {
     return false;
   }
 }
-var DEFAULT_CONFIG3;
+var AVAILABILITY_TTL_MS, MAX_AVAILABILITY_ENTRIES, availability;
 var init_embeddings = __esm({
   "packages/memory/dist/embeddings.js"() {
     "use strict";
-    DEFAULT_CONFIG3 = {
-      baseUrl: "http://localhost:11434",
-      model: "nomic-embed-text",
-      timeoutMs: 3e4
-    };
+    AVAILABILITY_TTL_MS = 3e4;
+    MAX_AVAILABILITY_ENTRIES = 128;
+    availability = /* @__PURE__ */ new Map();
   }
 });
 
@@ -74247,7 +74297,18 @@ var init_memoryIngestion = __esm({
         let graphNodes = 0;
         let graphEdges = 0;
         if (input.embedNow) {
-          embeddingsStored = await this.embedChunks(chunks);
+          const result = await this.embedChunks(chunks);
+          embeddingsStored = result.stored;
+          if (input.queueEmbedding !== false) {
+            for (const chunk of result.missing) {
+              this.store.enqueueJob({
+                jobType: "embed_chunk",
+                itemId: chunk.itemId,
+                chunkId: chunk.id,
+                payload: { embeddingSetSlug: this.store.getDefaultEmbeddingSet().slug }
+              });
+            }
+          }
         }
         if (input.maintainGraphNow) {
           const graph = maintainMemoryGraph(this.store, item);
@@ -74279,7 +74340,11 @@ var init_memoryIngestion = __esm({
               const chunk = this.store.getChunk(job.chunkId);
               if (!chunk)
                 throw new Error(`Missing chunk ${job.chunkId}`);
-              embeddedChunks += await this.embedChunks([chunk], String(job.payload["embeddingSetSlug"] ?? "default-full"));
+              const result = await this.embedChunks([chunk], String(job.payload["embeddingSetSlug"] ?? this.store.getDefaultEmbeddingSet().slug));
+              embeddedChunks += result.stored;
+              if (result.missing.length > 0) {
+                throw new Error("Embedding unavailable or invalid; no vector was stored for the pending chunk");
+              }
             } else if (job.jobType === "maintain_graph") {
               if (!job.itemId)
                 throw new Error("Graph job missing item_id");
@@ -74298,7 +74363,7 @@ var init_memoryIngestion = __esm({
         }
         return { claimed: jobs.length, completed, failed, embeddedChunks, graphItems };
       }
-      async refreshEmbeddings(limit2 = 200, embeddingSetSlug = "default-full") {
+      async refreshEmbeddings(limit2 = 200, embeddingSetSlug = this.store.getDefaultEmbeddingSet().slug) {
         const chunks = this.store.chunksMissingEmbedding(embeddingSetSlug, limit2);
         for (const chunk of chunks) {
           this.store.enqueueJob({
@@ -74310,23 +74375,28 @@ var init_memoryIngestion = __esm({
         }
         return { queued: chunks.length };
       }
-      async embedChunks(chunks, embeddingSetSlug = "default-full") {
+      async embedChunks(chunks, embeddingSetSlug = this.store.getDefaultEmbeddingSet().slug) {
         if (chunks.length === 0)
-          return 0;
+          return { stored: 0, missing: [] };
         const batch2 = chunks.length > 1 ? await generateEmbeddingBatch(chunks.map((chunk) => chunk.text), this.options.embedding) : [await generateEmbedding(chunks[0].text, this.options.embedding)];
         let stored = 0;
+        const missing2 = [];
         for (let index = 0; index < chunks.length; index++) {
           const result = batch2[index];
           const chunk = chunks[index];
-          if (!result || !chunk)
+          if (!chunk)
+            continue;
+          if (!result) {
+            missing2.push(chunk);
             continue;
+          }
           this.store.storeChunkEmbedding(chunk.id, result.vector, {
             embeddingSetSlug,
             model: result.model
           });
           stored++;
         }
-        return stored;
+        return { stored, missing: missing2 };
       }
       handleJobFailure(job, error) {
         const maxAttempts = Math.max(1, this.options.maxAttempts ?? 3);
@@ -75197,7 +75267,7 @@ function findNeighbors(episode, candidates, topK, minSimilarity) {
   return scored.slice(0, topK);
 }
 function linkEpisode(episode, episodeStore, graph, config) {
-  const cfg = { ...DEFAULT_CONFIG4, ...config };
+  const cfg = { ...DEFAULT_CONFIG3, ...config };
   const result = { episodeId: episode.id, linkedTo: [], linksCreated: 0 };
   if (!hasAssociativeEmbedding(episode))
     return result;
@@ -75244,11 +75314,11 @@ function batchLink(episodeStore, graph, config) {
   }
   return { processed, linksCreated: totalLinks };
 }
-var DEFAULT_CONFIG4;
+var DEFAULT_CONFIG3;
 var init_zettelkasten = __esm({
   "packages/memory/dist/zettelkasten.js"() {
     "use strict";
-    DEFAULT_CONFIG4 = {
+    DEFAULT_CONFIG3 = {
       topK: 3,
       minSimilarity: 0.3,
       evolutionThreshold: 0.6,
@@ -75648,7 +75718,7 @@ function extractQueryEntities(query) {
   return entities;
 }
 function personalizedPageRank(graph, seedNodeIds, config) {
-  const cfg = { ...DEFAULT_CONFIG5, ...config };
+  const cfg = { ...DEFAULT_CONFIG4, ...config };
   const scores = /* @__PURE__ */ new Map();
   if (seedNodeIds.length === 0)
     return scores;
@@ -75699,7 +75769,7 @@ function personalizedPageRank(graph, seedNodeIds, config) {
   return scores;
 }
 function retrieveByPPR(query, graph, episodeStore, config) {
-  const cfg = { ...DEFAULT_CONFIG5, ...config };
+  const cfg = { ...DEFAULT_CONFIG4, ...config };
   const queryEntities = extractQueryEntities(query);
   if (queryEntities.length === 0) {
     return { episodes: [], queryEntities: [], seedNodes: [], iterations: 0 };
@@ -75794,7 +75864,7 @@ function retrieveByPPR(query, graph, episodeStore, config) {
     iterations: cfg.maxIterations
   };
 }
-var DEFAULT_CONFIG5;
+var DEFAULT_CONFIG4;
 var init_pprRetrieval = __esm({
   "packages/memory/dist/pprRetrieval.js"() {
     "use strict";
@@ -75802,7 +75872,7 @@ var init_pprRetrieval = __esm({
     init_homeostaticRegulation();
     init_socialInfluence();
     init_embodiedTrace();
-    DEFAULT_CONFIG5 = {
+    DEFAULT_CONFIG4 = {
       damping: 0.5,
       maxIterations: 50,
       convergenceThreshold: 1e-6,
@@ -82669,11 +82739,11 @@ var init_embeddingDrift = __esm({
 });
 
 // packages/memory/dist/scoring.js
-var DEFAULT_CONFIG6, MemoryScorer;
+var DEFAULT_CONFIG5, MemoryScorer;
 var init_scoring = __esm({
   "packages/memory/dist/scoring.js"() {
     "use strict";
-    DEFAULT_CONFIG6 = {
+    DEFAULT_CONFIG5 = {
       recencyHalfLifeMs: 7 * 24 * 60 * 60 * 1e3,
       // 7 days
       minScore: 0.05,
@@ -82684,7 +82754,7 @@ var init_scoring = __esm({
     MemoryScorer = class {
       config;
       constructor(config) {
-        this.config = { ...DEFAULT_CONFIG6, ...config };
+        this.config = { ...DEFAULT_CONFIG5, ...config };
       }
       /**
        * Score a single memory entry.
@@ -178360,7 +178430,7 @@ var require_axios = __commonJS({
       });
       return config;
     }
-    var resolveConfig = (config) => {
+    var resolveConfig2 = (config) => {
       const newConfig = mergeConfig3({}, config);
       let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
       newConfig.headers = headers = AxiosHeaders$1.from(headers);
@@ -178404,7 +178474,7 @@ var require_axios = __commonJS({
     var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
     var xhrAdapter = isXHRAdapterSupported && function(config) {
       return new Promise(function dispatchXhrRequest(resolve108, reject) {
-        const _config3 = resolveConfig(config);
+        const _config3 = resolveConfig2(config);
         let requestData = _config3.data;
         const requestHeaders = AxiosHeaders$1.from(_config3.headers).normalize();
         let { responseType, onUploadProgress, onDownloadProgress } = _config3;
@@ -178759,7 +178829,7 @@ var require_axios = __commonJS({
           headers,
           withCredentials = "same-origin",
           fetchOptions
-        } = resolveConfig(config);
+        } = resolveConfig2(config);
         let _fetch = envFetch || fetch;
         responseType = responseType ? (responseType + "").toLowerCase() : "text";
         let composedSignal = composeSignals$1(
@@ -353754,8 +353824,8 @@ var init_ocr_pdf = __esm({
           });
         }
         const required = ["ocrmypdf", "tesseract", "gs"];
-        const availability = await Promise.all(required.map(async (command) => ({ command, available: await commandExists(command) })));
-        const missing2 = availability.filter((entry) => !entry.available).map((entry) => entry.command);
+        const availability2 = await Promise.all(required.map(async (command) => ({ command, available: await commandExists(command) })));
+        const missing2 = availability2.filter((entry) => !entry.available).map((entry) => entry.command);
         if (missing2.length) {
           return terminalOcrFailure({
             sourcePath: rawInput,
@@ -669705,8 +669775,10 @@ ${loadPrompt("agentic/system-small.md")}`;
       // window catches oscillation patterns (success → ENOENT → success → ENOENT)
       // that the consecutive counter misses.
       _consecutiveEnoent = 0;
+      // Lifecycle summaries are a run-level fallback. Model replies, however,
+      // must be delivered once for each response, including answers after tool work.
       _assistantTextEmitted = false;
-      // WO-E26: prevent double-emit
+      _modelTextEmittedThisResponse = false;
       _pendingStreamAssistantText = null;
       /**
        * Bounded pause envelope for one open stream. It stores one finalized raw
@@ -673299,6 +673371,7 @@ ${read3.content}`;
         } else if (requireCanonical) {
           throw new Error("outbound request has no canonical projection");
         }
+        this._modelTextEmittedThisResponse = false;
         const textProtocol = request.responseFormat || request.response_format ? void 0 : textProtocolOverride ?? (this.options.textToolMode ? "json" : resolveModelProfile(this.backend.model ?? "").toolCallFormat === "hermes-xml" ? "hermes-xml" : void 0);
         const streaming = this.options.streamEnabled && this.hasStreamingSupport();
         const backend = streaming ? { chatCompletion: (value2) => this.streamingRequest(value2, turn, textProtocol) } : this.backend;
@@ -683071,20 +683144,26 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
       flushPendingStreamAssistantText() {
         const pending2 = this._pendingStreamAssistantText;
         this._pendingStreamAssistantText = null;
-        if (!pending2 || this.aborted || this._assistantTextEmitted)
+        if (pending2)
+          this.emitModelAssistantText(pending2.content, pending2.turn);
+      }
+      /** The stream and batch consumers may see the same response; publish it once. */
+      emitModelAssistantText(content, turn) {
+        if (!content || this.aborted || this._modelTextEmittedThisResponse)
           return;
         const phase = this._interruptionLifecycle?.snapshot().phase;
         if (phase === "stopping" || phase === "stopped")
           return;
         this._observeExpectedOutcomeEffect("visible_response");
+        this._modelTextEmittedThisResponse = true;
+        this._assistantTextEmitted = true;
         this.emit({
           type: "assistant_text",
-          content: pending2.content,
+          content,
           source: "model_visible_text",
-          turn: pending2.turn,
+          turn,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
-        this._assistantTextEmitted = true;
       }
       /** Close a stream held at pause without retaining an event-per-token queue. */
       flushPendingPausedStreamTerminal() {
@@ -685361,6 +685440,7 @@ ${dynamicProjectContext}`
         let acceptedTaskCompleteOverride;
         let bruteForceCycle = 0;
         this._assistantTextEmitted = false;
+        this._modelTextEmittedThisResponse = false;
         this._pendingStreamAssistantText = null;
         this._pendingPausedStreamTerminal = null;
         this._expectedOutcomeObservedEffects.clear();
@@ -691825,16 +691905,7 @@ Only call task_complete when the task is actually complete and the evidence is f
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
             const cleanNonStream = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
-            if (cleanNonStream && !this._assistantTextEmitted) {
-              this._observeExpectedOutcomeEffect("visible_response");
-              this.emit({
-                type: "assistant_text",
-                content: cleanNonStream,
-                turn,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-              this._assistantTextEmitted = true;
-            }
+            this.emitModelAssistantText(cleanNonStream, turn);
             if (this.options.acceptTextOnlyCompletion && expectedOutcomeAllowsTextOnlyCompletion(this.options.expectedOutcomeContract) && cleanNonStream) {
               completed = true;
               summary = cleanNonStream;
@@ -692464,6 +692535,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 turn,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
+              this.emitModelAssistantText(content.replace(/<think>[\s\S]*?<\/think>/g, "").trim(), turn);
               if (/task.?complete|all tests pass/i.test(content)) {
                 const completionArgs = { summary: content };
                 const open8 = this.getOpenTodoItems();
@@ -724637,15 +724709,15 @@ function loadLiveSensorConfig(repoRoot) {
   try {
     const parsed = JSON.parse(readFileSync121(liveConfigPath(repoRoot), "utf8"));
     return {
-      ...DEFAULT_CONFIG7,
+      ...DEFAULT_CONFIG6,
       ...parsed,
       cameraOrientation: sanitizeCameraOrientation(parsed.cameraOrientation),
       cameraStreams: sanitizeCameraStreams(parsed.cameraStreams),
-      videoIntervalMs: Math.max(MIN_VIDEO_INTERVAL_MS, Number(parsed.videoIntervalMs ?? DEFAULT_CONFIG7.videoIntervalMs)),
-      audioIntervalMs: Math.max(MIN_AUDIO_INTERVAL_MS, Number(parsed.audioIntervalMs ?? DEFAULT_CONFIG7.audioIntervalMs))
+      videoIntervalMs: Math.max(MIN_VIDEO_INTERVAL_MS, Number(parsed.videoIntervalMs ?? DEFAULT_CONFIG6.videoIntervalMs)),
+      audioIntervalMs: Math.max(MIN_AUDIO_INTERVAL_MS, Number(parsed.audioIntervalMs ?? DEFAULT_CONFIG6.audioIntervalMs))
     };
   } catch {
-    return { ...DEFAULT_CONFIG7 };
+    return { ...DEFAULT_CONFIG6 };
   }
 }
 function readLiveSensorSnapshot(repoRoot) {
@@ -725180,7 +725252,7 @@ function formatLiveStatus(snapshot) {
   }
   return lines.join("\n");
 }
-var MIN_VIDEO_INTERVAL_MS, LOW_LATENCY_VIDEO_INTERVAL_MS, MIN_AUDIO_INTERVAL_MS, LOW_LATENCY_AUDIO_INTERVAL_MS, AUDIO_ACTIVITY_INTERVAL_MS, AUDIO_ACTIVITY_SAMPLE_SEC, DEFAULT_CAMERA_RESOLUTION, DEFAULT_CAMERA_FPS, DEFAULT_CONFIG7, managers, DASHBOARD_ANSI_STICKY_PATTERN, _liveDashboardMaximizedCamera, LiveSensorManager;
+var MIN_VIDEO_INTERVAL_MS, LOW_LATENCY_VIDEO_INTERVAL_MS, MIN_AUDIO_INTERVAL_MS, LOW_LATENCY_AUDIO_INTERVAL_MS, AUDIO_ACTIVITY_INTERVAL_MS, AUDIO_ACTIVITY_SAMPLE_SEC, DEFAULT_CAMERA_RESOLUTION, DEFAULT_CAMERA_FPS, DEFAULT_CONFIG6, managers, DASHBOARD_ANSI_STICKY_PATTERN, _liveDashboardMaximizedCamera, LiveSensorManager;
 var init_live_sensors = __esm({
   "packages/cli/src/tui/live-sensors.ts"() {
     init_dist5();
@@ -725198,7 +725270,7 @@ var init_live_sensors = __esm({
     AUDIO_ACTIVITY_SAMPLE_SEC = 0.2;
     DEFAULT_CAMERA_RESOLUTION = "1920x1080";
     DEFAULT_CAMERA_FPS = 8;
-    DEFAULT_CONFIG7 = {
+    DEFAULT_CONFIG6 = {
       videoEnabled: false,
       audioEnabled: false,
       audioOutputEnabled: false,
@@ -755162,12 +755234,12 @@ async function repairExpandedVariantIfStale(variantModel, fallbackBaseModel, bac
   if (!baseModel) {
     return { repaired: false, currentNumCtx: state5.currentNumCtx, baseModel: null, resolvedModel: variantName };
   }
-  const canonicalModel = expandedModelName(baseModel);
+  const canonicalModel2 = expandedModelName(baseModel);
   const hasCtx = state5.currentNumCtx > 0;
   const tooSmall = hasCtx && state5.currentNumCtx < targetNumCtx;
   const tooLarge = hasCtx && state5.currentNumCtx > Math.floor(targetNumCtx * 1.1);
   const needsCtxRepair = !hasCtx || tooSmall || tooLarge;
-  const needsCanonicalVariant = variantName !== canonicalModel;
+  const needsCanonicalVariant = variantName !== canonicalModel2;
   let repaired = false;
   if (needsCtxRepair) {
     const repairedCurrent = await createExpandedVariantNamedAsync(variantName, baseModel, specs, sizeGB, kvBytesPerToken, archMax);
@@ -755175,13 +755247,13 @@ async function repairExpandedVariantIfStale(variantModel, fallbackBaseModel, bac
   }
   let resolvedModel = variantName;
   if (needsCanonicalVariant) {
-    const canonicalCreated = await createExpandedVariantNamedAsync(canonicalModel, baseModel, specs, sizeGB, kvBytesPerToken, archMax);
+    const canonicalCreated = await createExpandedVariantNamedAsync(canonicalModel2, baseModel, specs, sizeGB, kvBytesPerToken, archMax);
     if (canonicalCreated) {
       repaired = true;
       resolvedModel = canonicalCreated;
     }
   } else {
-    resolvedModel = canonicalModel;
+    resolvedModel = canonicalModel2;
   }
   return { repaired, currentNumCtx: state5.currentNumCtx, baseModel, resolvedModel };
 }
@@ -845415,8 +845487,8 @@ This is an independent background session started from /background.`
   }
   const startupChecksPromise = (async () => {
     if (!isResumed && !isFirstRun()) {
-      const availability = await checkModelAvailability(currentConfig);
-      if (availability.status === "unavailable" && currentConfig.backendType === "ollama") {
+      const availability2 = await checkModelAvailability(currentConfig);
+      if (availability2.status === "unavailable" && currentConfig.backendType === "ollama") {
         writeContent(() => {
           renderWarning(
             `Model "${currentConfig.model}" not available. Use /model to pick one.`
@@ -849913,8 +849985,8 @@ ${c3.dim("(Use /quit to exit)")}
 async function shouldRunFirstRunSetup(config, firstRun = isFirstRun()) {
   if (config.backendType !== "ollama") return false;
   if (!firstRun) return false;
-  const availability = await checkModelAvailability(config);
-  return availability.status === "unavailable";
+  const availability2 = await checkModelAvailability(config);
+  return availability2.status === "unavailable";
 }
 async function runWithTUI(task, config, repoPath2, callbacks) {
   const repoRoot = resolve101(repoPath2 ?? cwd());

package/docs/DISCOVERY.json

@@ -35169,6 +35169,81 @@
         }
       ]
     },
+    {
+      "id": "guide.work-orders-runtime-health-remediation-wo-49-authored-final-delivery-uppercase",
+      "kind": "guide",
+      "title": "WO-49: Preserve the authored answer after tool work",
+      "summary": "Status: repository repair verified; scoped Git delivery in progress.",
+      "keywords": [
+        "work",
+        "orders",
+        "runtime",
+        "health",
+        "remediation",
+        "WO",
+        "49",
+        "authored",
+        "final",
+        "delivery",
+        "md"
+      ],
+      "maturity": "internal",
+      "audiences": [
+        "maintainer",
+        "large-context-agent"
+      ],
+      "layer": "documentation",
+      "interfaces": [
+        {
+          "type": "file",
+          "target": "docs/work-orders/runtime-health-remediation/WO-49-authored-final-delivery.md"
+        }
+      ],
+      "references": [
+        {
+          "type": "documentation",
+          "target": "docs/work-orders/runtime-health-remediation/WO-49-authored-final-delivery.md",
+          "relation": "canonical-artifact"
+        }
+      ]
+    },
+    {
+      "id": "guide.work-orders-runtime-health-remediation-wo-50-embedding-unavailability-uppercase",
+      "kind": "guide",
+      "title": "WO-50: Recover honestly from missing embeddings",
+      "summary": "Status: source repair in progress; requested Nomic re-pull completed.",
+      "keywords": [
+        "work",
+        "orders",
+        "runtime",
+        "health",
+        "remediation",
+        "WO",
+        "50",
+        "embedding",
+        "unavailability",
+        "md"
+      ],
+      "maturity": "internal",
+      "audiences": [
+        "maintainer",
+        "large-context-agent"
+      ],
+      "layer": "documentation",
+      "interfaces": [
+        {
+          "type": "file",
+          "target": "docs/work-orders/runtime-health-remediation/WO-50-embedding-unavailability.md"
+        }
+      ],
+      "references": [
+        {
+          "type": "documentation",
+          "target": "docs/work-orders/runtime-health-remediation/WO-50-embedding-unavailability.md",
+          "relation": "canonical-artifact"
+        }
+      ]
+    },
     {
       "id": "guide.work-orders-telegram-dmn-wo-22-dmn-outreach-and-learning-uppercase",
       "kind": "guide",

package/docs/DISCOVERY.md

@@ -594,6 +594,8 @@ Daemon equivalents are `GET /v1/discovery/bootstrap`, `GET /v1/discovery?q=<inte
 | `guide.work-orders-runtime-health-remediation-wo-46-shell-result-authority-uppercase` | WO-46: Preserve process authority for shell observations | Status: repository repair complete and delivered to origin/main. Publication and live validation remain with the user. |
 | `guide.work-orders-runtime-health-remediation-wo-47-diagnostic-execution-contract-uppercase` | WO-47: Validate and execute diagnostics without blocking the agent | Status: repository repair complete and delivered to origin/main. Publication and live validation remain with the user. |
 | `guide.work-orders-runtime-health-remediation-wo-48-conversation-result-evidence-uppercase` | WO-48: Retain command evidence in conversation results | Status: repository repair complete and delivered to origin/main. Publication and live validation remain with the user. |
+| `guide.work-orders-runtime-health-remediation-wo-49-authored-final-delivery-uppercase` | WO-49: Preserve the authored answer after tool work | Status: repository repair verified; scoped Git delivery in progress. |
+| `guide.work-orders-runtime-health-remediation-wo-50-embedding-unavailability-uppercase` | WO-50: Recover honestly from missing embeddings | Status: source repair in progress; requested Nomic re-pull completed. |
 | `guide.work-orders-telegram-dmn-wo-22-dmn-outreach-and-learning-uppercase` | WO-22: DMN outreach, DM sharing, and outcome learning | On 2026-09-03 at 17:07 PDT the bot posted in the OMNIUS group without being addressed. The operator asked whether this was self-induced reflection. |
 | `guide.work-orders-telegram-dropbear-context-rca-workorder` | Telegram Dropbear Context Engineering RCA Work Order | Observed run: /home/roko/Documents/Projects/Adjacent/telegramtest/.omnius, run id 1782873796963-i5r7mv. |
 | `guide.work-orders-wo-am-gaps-uppercase` | Associative Memory Gap Work Orders | Generated: 2026-04-13 Source: Deep audit of multimodal associative memory systems Status: READY FOR IMPLEMENTATION |

package/docs/work-orders/runtime-health-remediation/TRACKER.md

@@ -4,6 +4,13 @@
 **Checked-item rule:** code, focused tests, and named evidence must all exist
 **Last reconciled:** 2026-09-05
 
+## September 5 runtime 1.0.698 delivery and Ollama follow-up
+
+- [ ] [WO-49: authored final delivery](WO-49-authored-final-delivery.md): generated answer lost after earlier prose and tool work; source repair and real-runner Telegram regression in progress.
+- [ ] [WO-50: embedding unavailability](WO-50-embedding-unavailability.md): bounded missing-model recovery, truthful vector/job outcomes and exact model identity in progress. User-requested Nomic re-pull succeeded; installation metadata verified without inference.
+
+The separate 14:43 PDT router failure was a managed Ollama lane exiting mid-stream, followed by connection refused and recovery. The external broker does not retain its exit status/stderr, so the underlying exit cause remains unresolved; WO-50 records the evidence and external observability follow-up.
+
 ## September 5 post-publication field review
 
 [Runtime 1.0.697 field review](LIVE-TELEGRAM-LOG-REVIEW-2026-09-05.md): a useful assessment final was delivered at 13:41 PDT, supported by TypeScript and 21 passing tests. At the reviewed checkpoint, the next implementation run was active. No hard blocker was established; source-read false failures, malformed diagnostic input handling and conversation-mode report coverage triggered the repairs below. Native feature workflow selection and continuous typing are not established by this sample.

package/docs/work-orders/runtime-health-remediation/WO-49-authored-final-delivery.md

@@ -0,0 +1,39 @@
+# WO-49: Preserve the authored answer after tool work
+
+Status: repository repair verified; scoped Git delivery in progress.
+
+## Field evidence and cause
+
+Runtime 1.0.698, September 5, 2026, run `telegram-64ac9937dc7647a8-1788644624446-1` completed after 13 turns and 16 tools. Its last context dump (`2026-09-05T21-52-49-830Z-main-395f119a1f.json`, message 31) contains a 1,249-character tool-free answer with the tunnel URL and endpoint instructions. The next message asks for `task_complete`; that call supplies an internal summary but no optional `user_reply`. Telegram instead delivered a 1,735-character mechanical command report at 14:54:31 PDT. The final prompt still had 82.9% free context: this was delivery loss, not context exhaustion.
+
+The runner uses one run-wide `_assistantTextEmitted` flag to suppress both duplicate response delivery and later independent replies. Earlier prose consumes the flag. Telegram correctly invalidates earlier candidates after tool work, but never receives the later answer's `model_visible_text` event. A subsequent summary-only completion clears the stream buffer; the report is the only eligible final. Nonstream replies also lack the source tag required by the terminal reply contract.
+
+Selected evidence is copied with SHA-256 manifests under `/tmp/omnius-run-1788644624446-audit/` and `/tmp/omnius-ollama-failure-rurz8d5c/`. Source logs remain untouched. These local captures are diagnostic evidence, not repository test fixtures.
+
+## Repair ownership
+
+- `packages/orchestrator/src/agenticRunner.ts`: separate per-response model delivery from run-wide lifecycle-summary suppression; preserve safe pause/Stop boundaries; tag actual authored text in both loops and transports.
+- `packages/orchestrator/tests/`: regression coverage for distinct model responses, streaming deduplication, interruption and both loops.
+- `packages/cli/tests/telegram-streamed-terminal-answer.test.ts` and `telegram-terminal-delivery.test.ts`: actual runner-to-Telegram field sequence plus exact terminal identity and stale-answer controls.
+
+## Acceptance
+
+- [x] Earlier prose and tool work cannot suppress a later authored answer.
+- [x] A separate summary-only completion turn retains that answer; no raw-command fallback replaces it.
+- [x] Stream and batch paths tag actual model text consistently; a response emits exactly once.
+- [x] Both loops retain interruption ownership; pause holds output, resume emits once, Stop rejects late output.
+- [x] Intervening work and task replacement invalidate stale answers; unvalidated URLs remain subject to the existing evidence gate.
+- [ ] Record verification and scoped commit/push.
+
+## Limits
+
+The copied `•` bullets were not reproduced in repository formatting or JSON encoding: stored pre-format text uses ASCII hyphens, and the formatter emits a correct Unicode bullet. Do not invent an encoding repair without a failing byte-level case. Retaining the useful answer addresses the observed command dump; this order does not grant prose or shell stdout new completion or link-validation authority.
+
+
+## Verification
+
+- Before the source rebuild, the actual Telegram regression failed in both streamed and batch modes with the same mechanical command report as the field run. Its intervening-work negative control already passed. Baseline: `/tmp/omnius-terminal-stream-before.log`.
+- After repair, all three actual Telegram cases pass; four additional actual-runner cases cover main/brute loops and stream/batch transport, including repeated turn zero in the fallback loop and exactly-once authored events. Logs: `/tmp/omnius-terminal-stream-after.log`, `/tmp/omnius-assistant-text-emission.log`.
+- `OMNIUS_SQLITE_TESTS=1 pnpm --dir packages/orchestrator exec vitest run tests/agenticRunner-interruption.test.ts tests/structured-tool-authority.test.ts tests/agenticRunner.test.ts tests/conversation-report-runner.test.ts --maxWorkers=4 --minWorkers=1`: 276 passed across four suites. Combined with the four new producer cases: 280 distinct orchestrator checks. Log: `/tmp/omnius-wo49-orchestrator-focused.log`.
+- `pnpm --dir packages/cli exec vitest run tests/telegram-terminal-delivery.test.ts tests/telegram-streamed-terminal-answer.test.ts tests/telegram-conversation-evidence.test.ts tests/telegram-stream-timeout.test.ts --maxWorkers=4 --minWorkers=1`: 58 passed across four suites. Log: `/tmp/omnius-wo49-cli-focused.log`.
+- Orchestrator build passed (`/tmp/omnius-wo49-orchestrator-build.log`). All inference and Telegram delivery in these tests were mocked. Publication and live acceptance remain with the user.

package/docs/work-orders/runtime-health-remediation/WO-50-embedding-unavailability.md

@@ -0,0 +1,33 @@
+# WO-50: Recover honestly from missing embeddings
+
+Status: source repair in progress; requested Nomic re-pull completed.
+
+## Field evidence and operational remedy
+
+The Ollama broker recorded 102 missing-model errors for `nomic-embed-text:latest` between 14:45 and 15:09:55 PDT on September 5, 2026. Omnius is configured for `http://localhost:11434`, with no embedding model override in the running process. The errors return HTTP 404 from `/api/embed`. This reduces semantic retrieval; stored text and lexical retrieval are still available. The exact caller of every request in the bursts has not been established.
+
+At the user's explicit request, `POST /api/pull` for the exact tag returned `success` at 15:19:57 PDT. Subsequent `/api/tags` and `/api/show` metadata confirmed `nomic-embed-text:latest`, embedding capability, 137M/F16, 768 dimensions, digest `0a109f422b47e3a30ba2b10eca18548e944e8a23073ee3f3e947efcf3c45e59f`. No inference or model-load probe was sent; no services were restarted. Successful installation metadata does not establish live embedding execution.
+
+Passive journal follow-up through 15:25:50 PDT then recorded 51 `/api/embed` HTTP 200 responses and zero embedding 404s after the pull. The broker logged Nomic lanes ready at 15:22:07 and 15:22:12 for the existing workload. This is observed server recovery, not an agent-issued inference test or proof that every earlier missing embedding job was repaired. Capture and SHA-256 manifest: `/tmp/omnius-nomic-repull-20260905/`.
+
+## Confirmed source defects and repair ownership
+
+- `packages/memory/src/embeddings.ts`: a single missing-model response triggers an implicit pull and recursive retry; batch requests lack bounded availability backoff. Replace this with exact endpoint/model scoped availability caching and independent cancellation. Preserve the null failure contract, validate vectors, and honor configured model identity without substituting models. Model checks must match exact tags.
+- `packages/memory/src/memoryIngestion.ts`: jobs currently complete even when no embedding is stored. Use existing durable retry/backoff for failed embedding work; retain raw text and lexical search.
+- `packages/indexer/src/ollamaEmbeddings.ts`: any failed batch causes per-input retries and fabricated zero vectors. Report generation failure truthfully, reject malformed vectors, and limit legacy API fallback to an actual unsupported endpoint.
+- Matching hermetic tests in memory/indexer, plus dependent builds and relevant retrieval tests.
+
+## Acceptance
+
+- [ ] Missing-model bursts make bounded requests, with no implicit downloads or recursive retries.
+- [ ] Exact endpoint/model identity, TTL recovery and independent cancellation are tested.
+- [ ] Configuration honors the selected model; availability checks cannot match a different tag by prefix.
+- [ ] Failed generation cannot fabricate vectors or complete embedding jobs; text remains recoverable.
+- [ ] Compatibility handling cannot fan one model failure into one request per input.
+- [ ] Record verification and scoped commit/push.
+
+## Separate chat-server incident
+
+This embedding defect did not cause the observed router HTTP 503. At 14:43:43.457 PDT the broker logged an incomplete `/api/chat` read; at 14:43:43.469 its fresh retry hit connection refused. At 14:43:44.583 it reported `lane-121` stopped unexpectedly. The lane had been ready since 14:25:42 for `robit/qwen3.8-27b-obliterated-e03:27b` on GPU UUID `GPU-170a99ee-850f-2182-1050-4e8d3c87b6b0`. The broker served chat again at 14:44:09.532, and the main run subsequently produced its answer.
+
+No OOM kill, GPU Xid, segfault or coredump was found in the narrow incident journal. The external broker discards child stdout/stderr and omits PID/exit status in its prune warning (`/usr/local/libexec/ollama-unify-gpu-negotiator`, child spawn and `_prune_dead_lanes_locked`). Its exact exit mechanism remains unknown. An external broker follow-up needs retained child stderr and return-code logging to distinguish crash, signal and deliberate exit; this Omnius repair does not claim to fix that unknown cause. Hashed journal captures are under `/tmp/omnius-ollama-failure-aki8oz5k/`; the earlier incident window is under `/tmp/omnius-ollama-early-failure-_nsbctcb/`.

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.698",
+  "version": "1.0.699",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.698",
+      "version": "1.0.699",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.698",
+  "version": "1.0.699",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/library.js",