omnius 1.0.339 → 1.0.341

package/dist/index.js

@@ -560736,7 +560736,7 @@ var init_critic = __esm({
 function extractSubject(errorText) {
   if (!errorText)
     return null;
-  const PATTERNS = [
+  const PATTERNS2 = [
     // Quoted module / type / symbol after recognizable phrases
     /cannot find (?:module|name|type|symbol|reference|file|namespace)\s+['"`]([^'"`\n]{1,80})['"`]/i,
     /(?:undefined|unresolved)\s+(?:reference|import|symbol)\s+(?:to\s+)?['"`]([^'"`\n]{1,80})['"`]/i,
@@ -560751,7 +560751,7 @@ function extractSubject(errorText) {
     /\bcannot resolve\s+['"`]?([^'"`\n\s]{1,120})['"`]?/i,
     /\bmodule not found:?\s+['"`]?([^'"`\n\s]{1,120})['"`]?/i
   ];
-  for (const re of PATTERNS) {
+  for (const re of PATTERNS2) {
     const m2 = errorText.match(re);
     if (m2 && m2[1]) {
       const subj = m2[1].trim();
@@ -565070,6 +565070,79 @@ var init_consolidation_runtime = __esm({
   }
 });
 
+// packages/orchestrator/dist/completion-evidence-gate.js
+function classifyCompletionClaim(text2) {
+  const t2 = String(text2 || "");
+  for (const p2 of PATTERNS) {
+    if (p2.re.test(t2)) {
+      return { category: p2.category, requiresIndependentEvidence: true, requiredCheck: p2.check };
+    }
+  }
+  return { category: null, requiresIndependentEvidence: false, requiredCheck: "" };
+}
+function detectExitCodeMisread(text2) {
+  const t2 = String(text2 || "");
+  const nonzeroExit = /\bexit(?:ed|s)?\b[^.\n]{0,20}?\b(?:code\s*)?(?:[1-9]\d*|non-?zero)\b/i;
+  const successWord = /\b(success(?:ful|fully|ed)?|succeeded|done|passed|works?|working|fine|ok|complete[d]?)\b/i;
+  if (nonzeroExit.test(t2) && successWord.test(t2))
+    return true;
+  if (/\|\|\s*true\b|\bset \+e\b|2>\/dev\/null\s*;\s*(echo|exit 0)/i.test(t2))
+    return true;
+  return false;
+}
+function auditCompletionClaims(claims) {
+  const blockers = [];
+  for (const c8 of claims || []) {
+    const cls = classifyCompletionClaim(c8.text);
+    if (!cls.requiresIndependentEvidence || !cls.category)
+      continue;
+    if (c8.status !== "supported") {
+      blockers.push({ claim: String(c8.text || "").slice(0, 160), category: cls.category, requiredCheck: cls.requiredCheck });
+    }
+  }
+  return { ok: blockers.length === 0, blockers };
+}
+function completionEvidenceDirective() {
+  return [
+    "[Evidence-gated completion — do not pretend success]",
+    "Before you claim a task is done, optimize for 'is the end state actually correct?', NOT 'did I make the change?'. Each of these claim types REQUIRES an independent check from a DIFFERENT command than the one that made the change:",
+    "- A process is 'running/started/up' → re-probe liveness after a short delay (ps/pgrep, a health endpoint, or the listening port). A PID file or a launcher log is NOT proof it stayed alive — 'started' ≠ 'running'.",
+    "- Something is 'installed/available' → verify with `command -v`/`--version`/a package query, NOT the installer's own log.",
+    "- A bug is 'fixed' → re-run the ORIGINAL failing command/test and watch it pass, not just confirm the edit landed.",
+    "- A success in simulation/mock/dry-run mode → label it as SIMULATED; never present it as the real capability.",
+    "Exit codes: a non-zero exit is NOT success; a zero exit from a wrapper / `|| true` / `set +e` is NOT proof the underlying thing worked — inspect what actually happened.",
+    "If you cannot produce the independent evidence, say so plainly and mark the item unverified or partial — never report a success state you have not verified."
+  ].join("\n");
+}
+var PATTERNS;
+var init_completion_evidence_gate = __esm({
+  "packages/orchestrator/dist/completion-evidence-gate.js"() {
+    "use strict";
+    PATTERNS = [
+      {
+        category: "process_liveness",
+        re: /\b(running|started|launched|spun up|brought up|is up|listening|serving|alive|daemon (is|now)|service (is|now)|server (is|now)|booted|online)\b/i,
+        check: "Independently probe liveness AFTER a short delay: ps/pgrep for the actual process, a health endpoint, or `ss -ltnp` for the port — NOT the launcher log or a PID file (a PID file can exist while the process is dead)."
+      },
+      {
+        category: "installation",
+        re: /\b(installed|available in PATH|on the PATH|set up|provisioned|configured and ready|now available|dependency (is )?(present|installed))\b/i,
+        check: "Independently confirm presence: `command -v <bin>` / `<bin> --version` / package manager query (e.g. `apt-cache policy`, `pip show`) — NOT the installer's own success log."
+      },
+      {
+        category: "fix_confirmation",
+        re: /\b(fixed|resolved|corrected|patched|repaired|no longer (fails|errors|crashes)|works now|issue (is )?gone)\b/i,
+        check: "Re-run the ORIGINAL failing command/test and observe it now passes — an independent reproduction, not just confirming the edit was written."
+      },
+      {
+        category: "reality",
+        re: /\b(simulat\w+|mock\w*|stub\w*|fake|dry[- ]?run|--sim|placeholder mode|fallback mode)\b/i,
+        check: "This was a SIMULATED/mock run. Label it explicitly as simulated and do NOT present it as the real capability; verify against the real system before claiming the real success."
+      }
+    ];
+  }
+});
+
 // packages/orchestrator/dist/tool-batching.js
 function isConcurrencySafe(toolName, readOnlyHints) {
   if (CONCURRENT_SAFE_TOOLS.has(toolName))
@@ -568620,6 +568693,7 @@ var init_agenticRunner = __esm({
     init_dist5();
     init_exploration_fanout();
     init_consolidation_runtime();
+    init_completion_evidence_gate();
     init_tool_batching();
     init_hooks2();
     init_todo_context_chunker();
@@ -570710,6 +570784,18 @@ ${input.answerText ?? ""}`.toLowerCase().trim();
             this._completionLedger = reconcileClaimsWithEvidence(this._completionLedger);
             this._saveCompletionLedgerSafe();
           }
+          try {
+            const _audit = auditCompletionClaims(this._completionLedger.proposedClaims.map((c8) => ({ text: c8.text, status: c8.status })));
+            if (!_audit.ok) {
+              const _checks = _audit.blockers.map((b) => `• [${b.category}] "${b.claim}" → ${b.requiredCheck}`).join("\n");
+              this._completionCaveat = [
+                this._completionCaveat || "",
+                `[UNVERIFIED SUCCESS — run these independent checks before claiming done]
+${_checks}`
+              ].filter(Boolean).join("\n\n");
+            }
+          } catch {
+          }
         }
         const optOverride = this.options.backwardPassReview;
         const raw = (process.env["OMNIUS_BACKWARD_PASS"] || "on").toLowerCase();
@@ -573943,6 +574029,12 @@ Respond with your assessment, then take action.`;
         }
         const contextComposition = await this.assembleContext(task, context2);
         let systemPrompt = contextComposition.assembled;
+        try {
+          systemPrompt = `${systemPrompt}
+
+${completionEvidenceDirective()}`;
+        } catch {
+        }
         try {
           const _cap = getMediaCapability();
           const _tier = this.options.modelTier ?? "large";
@@ -590380,6 +590472,7 @@ __export(dist_exports3, {
   appendSteeringLedgerEntry: () => appendSteeringLedgerEntry,
   appendSteeringOutcome: () => appendSteeringOutcome,
   arcSummary: () => arcSummary,
+  auditCompletionClaims: () => auditCompletionClaims,
   buildAgentNotification: () => buildAgentNotification,
   buildAgentTypeSummary: () => buildAgentTypeSummary,
   buildCompletionScenarioDecomposition: () => buildCompletionScenarioDecomposition,
@@ -590400,6 +590493,7 @@ __export(dist_exports3, {
   chooseCheapModelRoute: () => chooseCheapModelRoute,
   claimAssertion: () => claimAssertion,
   classifyBreadth: () => classifyBreadth,
+  classifyCompletionClaim: () => classifyCompletionClaim,
   classifyHandoff: () => classifyHandoff,
   classifyOllamaProcesses: () => classifyOllamaProcesses,
   cleanForStorage: () => cleanForStorage,
@@ -590408,6 +590502,7 @@ __export(dist_exports3, {
   clearTurnState: () => clearTurnState,
   combineValidatorResults: () => combineValidatorResults,
   compilePersonalityPrompt: () => compilePersonalityPrompt,
+  completionEvidenceDirective: () => completionEvidenceDirective,
   compressFindings: () => compressFindings,
   computeArc: () => computeArc,
   computeStabilityHash: () => computeStabilityHash,
@@ -590425,6 +590520,7 @@ __export(dist_exports3, {
   decomposeSpec: () => decomposeSpec,
   deleteAgentTaskSidecar: () => deleteAgentTaskSidecar,
   deriveClaimsFromProposedText: () => deriveClaimsFromProposedText,
+  detectExitCodeMisread: () => detectExitCodeMisread,
   detectExplorationIntent: () => detectExplorationIntent,
   detectPressure: () => detectPressure,
   detectTaskType: () => detectTaskType,
@@ -590638,6 +590734,7 @@ var init_dist8 = __esm({
     init_memory_consolidation();
     init_exploration_fanout();
     init_consolidation_runtime();
+    init_completion_evidence_gate();
   }
 });
 
@@ -689463,6 +689560,41 @@ window.__omniusStores = {
 
 const conv = document.getElementById('conversation');
 const input = document.getElementById('input-area');
+// SUGGESTED FOLLOW-UP — ghost text (placeholder-grey) shown after a reply
+// completes; Tab accepts it as real text, typing dismisses it.
+const DEFAULT_INPUT_PLACEHOLDER = 'Type a message...';
+let chatFollowup = null;
+function setFollowupSuggestion(text) {
+  text = (text || '').trim();
+  if (!text || streaming) return;
+  if (input.value.trim().length > 0) return; // don't clobber what the user is typing
+  chatFollowup = text;
+  input.placeholder = text + '   (Tab \\u21E5)';
+}
+function clearFollowupSuggestion() {
+  if (chatFollowup !== null) { chatFollowup = null; input.placeholder = DEFAULT_INPUT_PLACEHOLDER; }
+}
+function acceptFollowupSuggestion() {
+  if (chatFollowup === null || input.value.trim().length > 0) return false;
+  const t = chatFollowup;
+  clearFollowupSuggestion();
+  input.value = t;
+  try { input.dispatchEvent(new Event('input')); } catch (e) {}
+  input.focus();
+  try { input.setSelectionRange(t.length, t.length); } catch (e) {}
+  return true;
+}
+async function fetchFollowupSuggestion() {
+  try {
+    if (!chatSessionId || input.value.trim().length > 0) return;
+    const r = await fetch('/v1/chat/suggest-followup', {
+      method: 'POST', headers: headers(), body: JSON.stringify({ session_id: chatSessionId }),
+    });
+    if (!r.ok) return;
+    const d = await r.json();
+    if (d && d.suggestion) setFollowupSuggestion(d.suggestion);
+  } catch (e) { /* best-effort */ }
+}
 const sendBtn = document.getElementById('send-btn');
 const modelSelect = document.getElementById('model-select');
 // Persist the selected model on every change so a browser refresh /
@@ -689567,6 +689699,8 @@ if (conv) {
 
 // Auto-resize textarea + WO-CHAT-CHECKIN typing detection
 input.addEventListener('input', () => {
+  // Dismiss the suggested follow-up the moment the user starts typing.
+  if (input.value.length > 0) clearFollowupSuggestion();
   input.style.height = 'auto';
   // OWUI-4: bump max from 120 (~6 lines) to 240 (~12 lines).
   input.style.height = Math.min(input.scrollHeight, 240) + 'px';
@@ -689597,6 +689731,10 @@ input.addEventListener('keydown', (e) => {
     if (e.key === 'Tab')         { e.preventDefault(); _slashPaletteAccept();  return; }
     if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); _slashPaletteAccept(); return; }
   }
+  // Suggested follow-up: Tab accepts the ghost text as real input.
+  if (e.key === 'Tab' && !e.shiftKey && chatFollowup !== null && input.value.trim().length === 0) {
+    if (acceptFollowupSuggestion()) { e.preventDefault(); return; }
+  }
   // OWUI-4: Cmd/Ctrl+Enter — always sends, never inserts a newline.
   if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) {
     e.preventDefault();
@@ -690309,6 +690447,7 @@ async function runSlashCommandInline(rawInput) {
 async function sendMessage() {
   const text = input.value.trim();
   if (!text || streaming) return;
+  clearFollowupSuggestion(); // a real send supersedes any ghost suggestion
 
   // ─── Slash command passthrough ────────────────────────────────────────
   // /foo args  → POST /v1/command, render result inline as a system
@@ -690686,6 +690825,8 @@ async function sendMessage() {
   chatAbortController = null;
   document.getElementById('send-btn').style.display = 'inline-block';
   document.getElementById('stop-btn').style.display = 'none';
+  // Reply finished — offer a suggested follow-up as ghost text in the input.
+  try { fetchFollowupSuggestion(); } catch (e) {}
   // OWUI-3: belt-and-braces — make sure the indicator is gone if we
   // reach this finally{} via an error path before the success branch
   // had a chance to call hideStreamingIndicator.
@@ -697329,6 +697470,7 @@ function getOpenApiSpec() {
       },
       "/v1/chat/sessions": { get: { summary: "List active chat sessions", tags: ["Chat"], responses: { 200: { description: "Session list" } } } },
       "/v1/chat/sessions/{id}/summarize": { post: { summary: "Generate + cache an inference-based title/summary for a session — body {force?, root?}", tags: ["Chat"], responses: { 200: { description: "Title + summary" }, 500: { description: "Generation failed" } } } },
+      "/v1/chat/suggest-followup": { post: { summary: "Suggest one short next-message follow-up for a session (ghost-text input) — body {session_id}", tags: ["Chat"], responses: { 200: { description: "{ suggestion }" } } } },
       "/v1/chat/sessions/{id}/status": { get: { summary: "Reactive recall: is this session running right now + unseen deltas since ?since=<seq> (running, phase, seq, partial, deltas[])", tags: ["Chat"], responses: { 200: { description: "Live run status + catch-up deltas" } } } },
       // ───── AIWG cascade ─────
       "/v1/aiwg": { get: { summary: "AIWG installation root + control map", tags: ["AIWG"], responses: { 200: { description: "AIWG installation summary" } } } },
@@ -698184,6 +698326,62 @@ var init_chat_run_registry = __esm({
   }
 });
 
+// packages/cli/src/api/chat-followup.ts
+function normalizeBaseUrl2(url) {
+  let u = (url || "").trim().replace(/\/+$/, "");
+  if (u.endsWith("/v1")) u = u.slice(0, -3);
+  return u;
+}
+function cleanSuggestion(raw) {
+  let s2 = (raw || "").trim();
+  s2 = s2.split("\n")[0].trim();
+  s2 = s2.replace(/^["'`*\-\d.\s]+/, "").replace(/["'`]+$/, "").trim();
+  if (/^(none|n\/?a|no follow|nothing)\b/i.test(s2)) return "";
+  return s2.length > 140 ? s2.slice(0, 139).trimEnd() + "…" : s2;
+}
+async function suggestFollowup(args) {
+  const turns = (args.turns || []).filter((t2) => t2 && t2.content && (t2.role === "user" || t2.role === "assistant"));
+  if (!turns.length || !args.config.model || !args.config.backendUrl) return "";
+  const transcript = turns.slice(-6).map((t2) => `${t2.role === "user" ? "User" : "Assistant"}: ${String(t2.content).slice(0, 800)}`).join("\n");
+  try {
+    const url = normalizeBaseUrl2(args.config.backendUrl) + "/v1/chat/completions";
+    const headers = { "Content-Type": "application/json" };
+    if (args.config.apiKey) headers["Authorization"] = `Bearer ${args.config.apiKey}`;
+    const body = {
+      model: args.config.model,
+      messages: [
+        {
+          role: "system",
+          content: "You suggest the single most likely NEXT message the user would send to continue this conversation. Write it in the user's voice (imperative, first person), as if they typed it. Reply with ONLY that one short prompt — no quotes, no preamble, no markdown, max ~12 words. If no natural follow-up exists, reply with exactly: NONE."
+        },
+        { role: "user", content: `Conversation so far:
+${transcript}
+
+The user's likely next message:` }
+      ],
+      temperature: 0.4,
+      max_tokens: 40,
+      stream: false
+    };
+    const resp = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(args.timeoutMs ?? 12e3)
+    });
+    if (!resp.ok) return "";
+    const data = await resp.json();
+    return cleanSuggestion(data?.choices?.[0]?.message?.content ?? "");
+  } catch {
+    return "";
+  }
+}
+var init_chat_followup = __esm({
+  "packages/cli/src/api/chat-followup.ts"() {
+    "use strict";
+  }
+});
+
 // packages/cli/src/docker.ts
 import { execSync as execSync59, spawn as spawn32 } from "node:child_process";
 import { existsSync as existsSync158, mkdirSync as mkdirSync99, writeFileSync as writeFileSync84 } from "node:fs";
@@ -706426,6 +706624,24 @@ ${historyLines}
       });
       return;
     }
+    if (pathname === "/v1/chat/suggest-followup" && method === "POST") {
+      if (!checkAuth(req3, res, "read")) return;
+      const fbBody = await parseJsonBody(req3);
+      const sid = fbBody?.session_id ? String(fbBody.session_id) : "";
+      const session = sid ? lookupSession(sid) : null;
+      const turns = session ? session.messages.filter((m2) => m2 && (m2.role === "user" || m2.role === "assistant") && typeof m2.content === "string").map((m2) => ({ role: m2.role, content: m2.content })) : [];
+      if (turns.length === 0) {
+        jsonResponse(res, 200, { suggestion: "" });
+        return;
+      }
+      const cfg = loadConfig();
+      const suggestion = await suggestFollowup({
+        turns,
+        config: { backendUrl: cfg.backendUrl, model: cfg.model, apiKey: cfg.apiKey }
+      });
+      jsonResponse(res, 200, { suggestion });
+      return;
+    }
     const chatSessionMatch = pathname.match(/^\/v1\/chat\/sessions\/([^/]+)$/);
     if (chatSessionMatch) {
       const sid = decodeURIComponent(chatSessionMatch[1]);
@@ -709080,6 +709296,7 @@ var init_serve = __esm({
     init_omnius_directory();
     init_session_summary();
     init_chat_run_registry();
+    init_chat_followup();
     init_omnius_directory();
     init_command_registry();
     init_profiles();

package/docs/reference/rest-api.md

@@ -52,6 +52,7 @@ pnpm docs:check
 | `GET` | `/api/tags` | Ollama-compatible model tags |
 | `GET` | `/v1/chat/sessions` | Active chat sessions |
 | `POST` | `/v1/chat/sessions/{id}/summarize` | Generate + cache an inference-based session title/summary |
+| `POST` | `/v1/chat/suggest-followup` | Suggest one short next-message follow-up (ghost-text input) |
 | `GET` | `/v1/chat/sessions/{id}/status` | Reactive recall: live run status + unseen deltas (`?since=<seq>`) |
 | `POST` | `/v1/chat/check-in` | Steering check-in for active chat |
 

package/npm-shrinkwrap.json

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

package/package.json

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