omnius 1.0.920 → 1.0.921

package/dist/index.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/index.js
-size: 39070631 bytes
-sha256: 71b2e7cbc291275599529d64b17cd57bb57d1d0c3e7092ac2eaa543a89d9f3f9
+size: 39079539 bytes
+sha256: 5a35c2692d6eb0106e5507e145a3e20285073674687ae05e02ef11d4d312354c

package/dist/library.js

@@ -352804,6 +352804,125 @@ var StructuredMemoryExtractionQueue = class {
   }
 };
 
+// packages/orchestrator/dist/append-only-outbound.js
+var APPEND_ONLY_FRAME_UPDATE_MARKER = "[ACTIVE TASK FRAME UPDATE v1]";
+var APPEND_ONLY_HOST_MESSAGE_MARKER = "[HOST RUNTIME MESSAGE v1: host-authored, not from the user]";
+var APPEND_ONLY_MAX_UPDATE_CHARS = 24e3;
+function projectionMarker(message, kinds3) {
+  if (typeof message.content !== "string")
+    return void 0;
+  if (message.content.startsWith(APPEND_ONLY_FRAME_UPDATE_MARKER))
+    return APPEND_ONLY_FRAME_UPDATE_MARKER;
+  if (message.role !== "system")
+    return void 0;
+  return kinds3.find((kind) => message.content.startsWith(kind.marker))?.marker;
+}
+function sameMessage(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function renderProjectionLineDiff(before, after) {
+  const a = before.split("\n"), b = after.split("\n");
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head])
+    head++;
+  let tail = 0;
+  while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail])
+    tail++;
+  const midA = a.slice(head, a.length - tail), midB = b.slice(head, b.length - tail);
+  if (midA.length === 0 && midB.length === 0)
+    return "";
+  const lcs = Array.from({ length: midA.length + 1 }, () => new Array(midB.length + 1).fill(0));
+  for (let i2 = midA.length - 1; i2 >= 0; i2--)
+    for (let j2 = midB.length - 1; j2 >= 0; j2--)
+      lcs[i2][j2] = midA[i2] === midB[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+  const ops = [];
+  let i = 0, j = 0;
+  while (i < midA.length || j < midB.length) {
+    if (i < midA.length && j < midB.length && midA[i] === midB[j]) {
+      ops.push({ kind: " ", line: midA[i], indexA: head + i });
+      i++;
+      j++;
+    } else if (j < midB.length && (i >= midA.length || lcs[i][j + 1] >= lcs[i + 1][j])) {
+      ops.push({ kind: "+", line: midB[j], indexA: head + i });
+      j++;
+    } else {
+      ops.push({ kind: "-", line: midA[i], indexA: head + i });
+      i++;
+    }
+  }
+  const out = [];
+  let inHunk = false;
+  for (const op of ops) {
+    if (op.kind === " ") {
+      inHunk = false;
+      continue;
+    }
+    if (!inHunk) {
+      const context = a[op.indexA - 1];
+      out.push(`@@ after: ${context === void 0 ? "(start)" : context.trim() ? context.slice(0, 160) : "(blank line)"}`);
+      inHunk = true;
+    }
+    out.push(`${op.kind} ${op.line}`);
+  }
+  return out.join("\n");
+}
+function projectAppendOnlyOutbound(input) {
+  const { key, messages: messages2, previous, kinds: kinds3 } = input;
+  const maxUpdateChars = input.maxUpdateChars ?? APPEND_ONLY_MAX_UPDATE_CHARS;
+  const firstProjection = messages2.findIndex((message) => projectionMarker(message, kinds3) !== void 0);
+  const base = firstProjection < 0 ? [...messages2] : messages2.slice(0, firstProjection);
+  const tail = firstProjection < 0 ? [] : messages2.slice(firstProjection);
+  const projections = /* @__PURE__ */ new Map();
+  const tailIsProjections = tail.every((message) => {
+    const marker = projectionMarker(message, kinds3);
+    if (!marker || marker === APPEND_ONLY_FRAME_UPDATE_MARKER || projections.has(marker))
+      return false;
+    projections.set(marker, message.content);
+    return true;
+  });
+  const full = (reason) => ({
+    messages: messages2,
+    mode: "full",
+    reason,
+    state: { key, sent: messages2, base, projections: tailIsProjections ? projections : /* @__PURE__ */ new Map(), updateChars: 0 }
+  });
+  if (!tailIsProjections)
+    return full("projections_not_at_tail");
+  if (!previous || previous.key !== key)
+    return full("new_chain");
+  if (base.length < previous.base.length || previous.base.some((message, index) => !sameMessage(message, base[index])))
+    return full("history_rewritten");
+  if (projections.size !== previous.projections.size || [...projections.keys()].some((marker) => !previous.projections.has(marker)))
+    return full("projection_kinds_changed");
+  const updates = [];
+  for (const kind of kinds3) {
+    const now2 = projections.get(kind.marker);
+    if (now2 === void 0)
+      continue;
+    const diff = renderProjectionLineDiff(previous.projections.get(kind.marker), now2);
+    if (diff)
+      updates.push(`[${kind.label}]
+${diff}`);
+  }
+  const update = updates.length ? [
+    APPEND_ONLY_FRAME_UPDATE_MARKER,
+    "Host runtime update, not a message from the user. The task frame and context blocks in the system prompt are from an earlier turn. Apply these line changes to them in order; the result is the current state. Lines marked - are no longer true; lines marked + are new.",
+    ...updates
+  ].join("\n") : "";
+  const updateChars = previous.updateChars + update.length;
+  if (updateChars > maxUpdateChars)
+    return full("update_budget_exceeded");
+  const appended = base.slice(previous.base.length).map((message) => message.role === "system" && typeof message.content === "string" ? { ...message, role: "user", content: `${APPEND_ONLY_HOST_MESSAGE_MARKER}
+${message.content}` } : message);
+  const sent = [...previous.sent, ...appended, ...update ? [{ role: "user", content: update }] : []];
+  return {
+    messages: sent,
+    mode: "extended",
+    reason: update ? "extended_with_update" : "extended_unchanged",
+    state: { key, sent, base, projections, updateChars }
+  };
+}
+
 // packages/orchestrator/dist/source-read-evidence.js
 init_dist5();
 import { createHash as createHash60 } from "node:crypto";
@@ -389669,6 +389788,10 @@ var AgenticRunner = class _AgenticRunner {
   _toolExposureRevision = 0;
   /** Exposure revision the most recent tool definitions were built from. */
   _toolDefsExposureRevision = -1;
+  /** Previous primary request, for the append-only outbound projection. */
+  _appendOnlyOutbound;
+  /** Per primary turn: whether the request extended the previous one, and why not when it did not. */
+  appendOnlyOutboundDecisions = [];
   /** Selected method definition only; observation/status counters do not change schemas. */
   _selectedWorkToolExposureKey = null;
   pendingRuntimeGuidanceMessages = [];
@@ -396402,6 +396525,54 @@ ${workflowStatus}` } : {}
       this._contextAdmissionOutputIntents.set(request, Math.max(this._contextAdmissionOutputIntents.get(request) ?? 0, floor));
     }
   }
+  /**
+   * Primary turns only: send the previous request verbatim plus this turn's history and a compact
+   * frame update, so hybrid/recurrent models resume from their KV checkpoint instead of re-reading
+   * the whole prompt (see append-only-outbound.ts). Falls back to the full request whenever the
+   * extension would need compaction that the full request does not.
+   */
+  _applyAppendOnlyOutboundProjection(request) {
+    if (process.env["OMNIUS_APPEND_ONLY_OUTBOUND"] === "0" || !request.logicalRequestId?.endsWith(":primary"))
+      return;
+    if (process.env["OMNIUS_APPEND_ONLY_OUTBOUND"] !== "1" && this.backend.prefersAppendOnlyPrompts?.() !== true)
+      return;
+    const key = JSON.stringify([
+      this.currentArtifactRunId(),
+      this._taskEpoch,
+      _createHash("sha256").update(JSON.stringify(request.tools ?? [])).digest("hex")
+    ]);
+    const steering = this._activeSteering;
+    const steeringPending = Boolean(this._currentSteeringReplyPending() || steering?.input.taskEpoch === this._taskEpoch && steering.gatesOldPlan && steering.requiresReconciliation && !steering.reconciliation);
+    const projected = projectAppendOnlyOutbound({
+      key,
+      messages: request.messages,
+      previous: steeringPending ? void 0 : this._appendOnlyOutbound,
+      kinds: [
+        { marker: CANONICAL_TASK_FRAME_MARKER, label: "canonical task frame" },
+        { marker: _AgenticRunner.CONTEXT_FRAME_MARKER, label: "active context frame" },
+        { marker: "[TELEGRAM PASSIVE HISTORY", label: "passive chat history" }
+      ]
+    });
+    if (steeringPending)
+      projected.reason = "steering_pending";
+    const record9 = (mode, reason) => {
+      this.appendOnlyOutboundDecisions.push({ logicalRequestId: request.logicalRequestId, mode, reason });
+      if (this.appendOnlyOutboundDecisions.length > 64)
+        this.appendOnlyOutboundDecisions.shift();
+    };
+    if (projected.mode === "extended") {
+      const fullBudget = this._outboundRequestBudget(request);
+      const extendedBudget = this._outboundRequestBudget({ ...request, messages: projected.messages });
+      if (extendedBudget.compactionEligible && !fullBudget.compactionEligible) {
+        this._appendOnlyOutbound = { ...projected.state, sent: request.messages, updateChars: 0 };
+        record9("full", "extension_needs_compaction");
+        return;
+      }
+      request.messages = projected.messages;
+    }
+    this._appendOnlyOutbound = projected.state;
+    record9(projected.mode, projected.reason);
+  }
   _applyTelegramPassiveHistoryProjection(request, turn) {
     this._preparePrimaryOutputReservation(request);
     const source = this._telegramPassiveHistory;
@@ -396607,6 +396778,7 @@ ${workflowStatus}` } : {}
       this._applyCanonicalOutboundProjection(request, turn);
     }
     await this._applyUnifiedMemoryCompilationWithLifecycle(request);
+    this._applyAppendOnlyOutboundProjection(request);
     this._applyContextAdmission(request);
     if ((this._lastContextAdmission?.decision === "reject" || request.preparedContextCapacity && !this._currentPreparedContextCapacity(request)) && await this._prepareRequestContextCapacity(request))
       this._applyContextAdmission(request, { allowContentCompaction: false });
@@ -431446,6 +431618,13 @@ var OllamaAgenticBackend = class _OllamaAgenticBackend {
       localReadiness: (error) => this.usesLocalInferenceReadiness() && error instanceof InferenceHttpError ? localHttpReadinessReason(error.status, error.responseJson) : void 0
     });
   }
+  /**
+   * Local Ollama (and the llama.cpp runners behind it) is where re-reading the whole prompt each
+   * turn was measured: 21-31k tokens per turn on a hybrid 27B model. Remote APIs keep today's shape.
+   */
+  prefersAppendOnlyPrompts() {
+    return this.usesLocalGpuAdmission();
+  }
   /** Remote endpoints never reserve a GPU on this host. */
   usesLocalGpuAdmission() {
     return this._provider.protocol === "ollama" && ["localhost", "127.0.0.1", "[::1]", "::1"].includes(new URL(this.baseUrl).hostname);

package/npm-shrinkwrap.json

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

package/package.json

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