omnius 1.0.541 → 1.0.542

package/dist/index.js

@@ -583238,6 +583238,36 @@ var init_completion_resolution_verifier = __esm({
 });
 
 // packages/orchestrator/dist/evidenceBranch.js
+function buildBranchExtractionBrief(input) {
+  const path16 = cleanBriefText(input.path, 320) || "the requested file";
+  const intent = firstBriefText([
+    input.assistantIntent,
+    input.trajectoryNextAction,
+    input.currentStep
+  ]);
+  const openQuestion = cleanBriefText(input.trajectoryOpenQuestion, 280);
+  const focus = openQuestion || intent;
+  const request = openQuestion ? `Determine the exact file-local facts in ${path16} that answer this unresolved agent question: ${openQuestion}` : intent ? `Identify the exact file-local facts in ${path16} that the active agent needs before it can ${asActionClause(intent)}.` : `Identify the exact declarations, behavior, and configuration in ${path16} needed to choose the next narrow action.`;
+  const triggerEvidence = uniqueBriefLines([
+    `The active action is a whole-file read of ${path16}; disk inspection found ${Math.max(0, input.lineCount)} lines / ${Math.max(0, input.byteCount)} bytes, so the parent context would otherwise receive only a preview.`,
+    input.trajectoryAssessment ? `Current trajectory assessment: ${cleanBriefText(input.trajectoryAssessment, 360)}` : "No current file-level evidence has been returned to the parent yet.",
+    input.currentStep ? `Current task step: ${cleanBriefText(input.currentStep, 260)}` : "",
+    input.recentFailure ? `Recent unresolved evidence: ${cleanBriefText(input.recentFailure, 320)}` : ""
+  ]);
+  const returnContract = focus ? `Return only the exact declarations, values, behavior, and line spans that resolve: ${focus}` : "Return only the exact declarations, values, behavior, and line spans needed for the next safe action.";
+  const retrievalQuery = uniqueBriefLines([
+    path16,
+    focus,
+    openQuestion,
+    "relevant declarations behavior configuration line spans"
+  ]).join(" ");
+  return {
+    request: cleanBriefText(request, 520),
+    triggerEvidence: triggerEvidence.slice(0, 4),
+    returnContract: cleanBriefText(returnContract, 520),
+    retrievalQuery: cleanBriefText(retrievalQuery, 700)
+  };
+}
 function buildStructuralPreview2(lines, path16, query) {
   const n2 = lines.length;
   const clip3 = (l2) => l2.length > 180 ? l2.slice(0, 180) + "…" : l2;
@@ -583264,6 +583294,29 @@ function queryTerms(query) {
     ...new Set(query.toLowerCase().replace(/[^a-z0-9_<>./-]+/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS2.has(w)))
   ];
 }
+function cleanBriefText(value2, max) {
+  const clean5 = String(value2 ?? "").replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x1F\x7F]/g, " ").replace(/\s+/g, " ").trim();
+  return clean5.length > max ? `${clean5.slice(0, Math.max(0, max - 1))}…` : clean5;
+}
+function firstBriefText(values) {
+  for (const value2 of values) {
+    const clean5 = cleanBriefText(value2, 320);
+    if (!clean5)
+      continue;
+    if (/^take one narrow, evidence-backed action/i.test(clean5))
+      continue;
+    return clean5;
+  }
+  return "";
+}
+function uniqueBriefLines(values) {
+  return [
+    ...new Set(values.map((value2) => cleanBriefText(value2, 700)).filter(Boolean))
+  ];
+}
+function asActionClause(value2) {
+  return cleanBriefText(value2, 320).replace(/^to\s+/i, "").replace(/[.?!]+$/, "").replace(/^([A-Z])/, (match) => match.toLowerCase());
+}
 function selectWindows(lines, terms2) {
   const matched = [];
   for (let i2 = 0; i2 < lines.length; i2++) {
@@ -583314,12 +583367,17 @@ function selectWindows(lines, terms2) {
     score: m2.score
   }));
 }
-function extractionPrompt(query, path16, windows) {
+function extractionPrompt(brief, path16, windows) {
   const blocks = windows.map((w) => `--- ${path16} lines ${w.start}-${w.end} ---
 ${w.text}`).join("\n\n");
   return [
-    `You are an extraction worker in a throwaway context. Extract ONLY what answers the query; do not summarize the whole file.`,
-    `Query: ${query}`,
+    `You are an extraction worker in a throwaway context. Extract ONLY the information requested by the active agent; do not summarize the whole file.`,
+    `[AGENTIC BRANCH REQUEST]`,
+    `Request: ${brief.request}`,
+    `Why this branch is needed now:`,
+    ...brief.triggerEvidence.map((evidence) => `- ${evidence}`),
+    `Return contract: ${brief.returnContract}`,
+    `Retrieval focus: ${brief.retrievalQuery}`,
     ``,
     `File excerpts:`,
     blocks,
@@ -583358,7 +583416,14 @@ function parseExtraction(raw) {
   };
 }
 async function extractEvidence(opts) {
-  const { path: path16, query, content, fileVersion, backend } = opts;
+  const { path: path16, content, fileVersion, backend } = opts;
+  const brief = opts.brief ?? buildBranchExtractionBrief({
+    path: path16,
+    lineCount: content.split("\n").length,
+    byteCount: content.length,
+    assistantIntent: opts.query
+  });
+  const query = brief.retrievalQuery || opts.query;
   const lines = content.split("\n");
   const terms2 = queryTerms(query);
   if (terms2.length > 0) {
@@ -583433,7 +583498,7 @@ async function extractEvidence(opts) {
       const resp = await backend.chatCompletion({
         messages: [
           { role: "system", content: "You extract precise facts from file excerpts. Output ONLY a JSON object." },
-          { role: "user", content: extractionPrompt(query, path16, windows) }
+          { role: "user", content: extractionPrompt(brief, path16, windows) }
         ],
         tools: [],
         temperature: 0,
@@ -595289,6 +595354,28 @@ ${notice}`;
           return "unknown";
         return entry.stale ? "stale" : "fresh";
       }
+      /**
+       * Turn a large whole-file read into an explicit request from the active
+       * agent state, rather than treating the original user prompt as the query.
+       */
+      _buildBranchExtractionBrief(input) {
+        const visibleAssistantIntent = [...input.messages].reverse().find((message2) => message2.role === "assistant" && typeof message2.content === "string" && message2.content.trim().length > 0);
+        const assistantIntent = visibleAssistantIntent ? sanitizeTrajectoryText(sanitizeModelVisibleContextText(String(visibleAssistantIntent.content)), 320) : "";
+        const trajectory = this._trajectoryCheckpoint;
+        const latestFailure = this._recentFailures.at(-1);
+        const recentFailure = latestFailure ? `${latestFailure.tool} at turn ${latestFailure.turn}: ${sanitizeTrajectoryText(latestFailure.error || latestFailure.output, 320)}` : "";
+        return buildBranchExtractionBrief({
+          path: input.path,
+          lineCount: input.lineCount,
+          byteCount: input.byteCount,
+          assistantIntent,
+          trajectoryAssessment: trajectory?.situationAssessment,
+          trajectoryNextAction: trajectory?.nextAction || this._taskState.nextAction,
+          trajectoryOpenQuestion: trajectory?.openQuestions[0],
+          currentStep: this._taskState.currentStep,
+          recentFailure
+        });
+      }
       /**
        * Rebuild the one current checkpoint at the context boundary. This shared
        * method is deliberately used by normal and brute-force loops via
@@ -600849,15 +600936,17 @@ Respond with EXACTLY this structure before your next tool call:
                     }
                   }
                   if (fullContent && shouldBranchRead(trueBytes, trueLines, false)) {
-                    const lastAssistant = [...messages2].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
-                    const query = [
-                      this._taskState.goal ?? "",
-                      typeof lastAssistant?.content === "string" ? lastAssistant.content : ""
-                    ].join(" ").trim().slice(0, 400) || "key facts, configuration, and structure";
+                    const branchBrief = this._buildBranchExtractionBrief({
+                      path: pRaw,
+                      lineCount: trueLines,
+                      byteCount: trueBytes,
+                      messages: messages2
+                    });
                     try {
                       const ev = await extractEvidence({
                         path: pRaw,
-                        query,
+                        query: branchBrief.retrievalQuery,
+                        brief: branchBrief,
                         content: fullContent,
                         // the REAL body, not the preview
                         fileVersion: this._worldFacts.files.get(pRaw)?.writeCount ?? 0,
@@ -600868,7 +600957,11 @@ Respond with EXACTLY this structure before your next tool call:
                       });
                       output = [
                         `[BRANCH-EXTRACT] ${pRaw} is large (${trueLines} lines, ${trueBytes} bytes); a whole-file read only returns a preview, so it was read in an isolated branch and distilled.`,
-                        `Distilled for: "${query.slice(0, 160)}"`,
+                        `[AGENTIC EXTRACTION REQUEST] ${branchBrief.request}`,
+                        `Evidence driving this request:`,
+                        ...branchBrief.triggerEvidence.map((evidence) => `- ${evidence}`),
+                        `Looking for: ${branchBrief.returnContract}`,
+                        `Retrieval focus: "${branchBrief.retrievalQuery.slice(0, 240)}"`,
                         `Relevant evidence (lines ${ev.sourceStart ?? "?"}-${ev.sourceEnd ?? "?"}, confidence ${ev.confidence.toFixed(2)}):`,
                         ev.claim,
                         `If you need a different region, call file_read with a specific offset+limit. Do NOT re-read the whole file — you already have the relevant content above.`

package/npm-shrinkwrap.json

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

package/package.json

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