omnius 1.0.664 → 1.0.666

package/.aiwg/addons/omnius-docs/skills/browser-interaction-validation/SKILL.md

@@ -7,8 +7,10 @@ compaction_strategy: structured
 # browser-interaction-validation
 
 Validate user-facing browser flows with `playwright_browser` as the canonical
-runtime. A page loading, a successful click receipt, a screenshot, or static
-source assertions alone do **not** prove that a requested interaction worked.
+runtime. A page loading, a successful click receipt, an immediate screenshot,
+or static source assertions alone do **not** prove that a requested interaction
+worked. Some failures appear only after the page remains active. GPU and WebGL
+failures can also differ between headless and headed browsers.
 
 ## Triggers
 
@@ -39,9 +41,12 @@ static checks separately as static evidence.
 1. Use `playwright_browser` for the entire flow. Do not switch to
    `browser_action` (Selenium) mid-flow; it is a separate browser session and
    loses page state. Use Selenium only as an explicit legacy fallback.
-2. Navigate to the live URL, then call `observe_bundle` before interacting.
-   Preserve URL, relevant DOM/a11y selectors, screenshot, page errors, console,
-   and network observations.
+2. Start with `validate_lifecycle`. Give it the live URL, an explicit
+   postcondition, and a finite `observation_ms`. This starts diagnostics before
+   navigation and holds the page open after load. For GUI, GPU, WebGL, WebGPU,
+   canvas, or animation claims, set `headless=false` and `force_new=true`. If a
+   graphical display is unavailable, report the headed check as blocked. Do not
+   substitute a clean headless run as proof.
 3. Choose a stable locator: prefer `data-testid`, then accessible role/name,
    then a specific CSS selector. Avoid ordinal or broad selectors that can race
    reactive re-renders.
@@ -52,9 +57,11 @@ static checks separately as static evidence.
    Re-query after a detached-element/re-render failure; do not retry a stale
    handle blindly. If a stable locator is unavailable, report that as a
    product-testability finding.
-6. Wait for the specific state, then capture post-action `observe_bundle` and
-   a focused DOM/text/a11y observation that proves the postcondition. Include
-   page errors, console errors, and failed network requests in the result.
+6. After the action, call `observe_window` with the expected state and a finite
+   `observation_ms`. Keep the same browser session alive while delayed failures
+   surface. Review the window-scoped page errors, console errors, failed network
+   requests, DOM state, and screenshot. Use `observe_bundle` only for an
+   instantaneous session summary when a timed observation is not required.
 7. Close by listing every requested interaction with its evidence outcome,
    receipt/artifact references, and any precise remediation. Call
    `task_complete` when the implementation work is done; verifier feedback is

package/dist/api/py-embed.js

@@ -289947,7 +289947,6 @@ init_process_lifecycle();
 import { dirname, join, resolve as resolve2 } from "node:path";
 import { homedir as homedir2, tmpdir } from "node:os";
 init_vision();
-var dynamicImport = new Function("mod", "return import(mod)");
 var PLAYWRIGHT_RUNTIME_DIR = join(homedir2(), ".omnius", "playwright-runtime");
 var PLAYWRIGHT_BROWSERS_DIR = join(PLAYWRIGHT_RUNTIME_DIR, "browsers");
 

package/dist/index.js

@@ -63552,6 +63552,30 @@ function pushBounded(buf, item) {
   if (buf.length > MAX_BUFFER)
     buf.splice(0, buf.length - MAX_BUFFER);
 }
+function captureBrowserDiagnosticCursor() {
+  return {
+    startedAtMs: Date.now(),
+    consoleIndex: consoleBuffer.length,
+    networkIndex: networkBuffer.length,
+    errorIndex: errorBuffer.length,
+    websocketIndex: wsBuffer.length,
+    crashCount
+  };
+}
+function diagnosticEntriesAfter(entries2, index, startedAtMs) {
+  return index <= entries2.length ? entries2.slice(index) : entries2.filter((entry) => entry.ts >= startedAtMs);
+}
+function browserDiagnosticWindow(cursor) {
+  return {
+    startedAtMs: cursor.startedAtMs,
+    endedAtMs: Date.now(),
+    console: diagnosticEntriesAfter(consoleBuffer, cursor.consoleIndex, cursor.startedAtMs),
+    network: diagnosticEntriesAfter(networkBuffer, cursor.networkIndex, cursor.startedAtMs),
+    errors: diagnosticEntriesAfter(errorBuffer, cursor.errorIndex, cursor.startedAtMs),
+    websockets: diagnosticEntriesAfter(wsBuffer, cursor.websocketIndex, cursor.startedAtMs),
+    crashCount: Math.max(0, crashCount - cursor.crashCount)
+  };
+}
 function which(cmd) {
   try {
     const out = execFileSync("which", [cmd], {
@@ -63663,6 +63687,11 @@ function asOptionalBoolean(value2) {
 function defaultPlaywrightHeadless() {
   return asOptionalBoolean(process.env["OMNIUS_PLAYWRIGHT_HEADLESS"] ?? process.env["OMNIUS_BROWSER_HEADLESS"]) ?? true;
 }
+function hasGraphicalBrowserDisplay() {
+  if (process.platform !== "linux")
+    return true;
+  return Boolean(process.env["DISPLAY"]?.trim() || process.env["WAYLAND_DISPLAY"]?.trim());
+}
 async function installPlaywrightBrowser() {
   try {
     mkdirSync18(PLAYWRIGHT_RUNTIME_DIR, { recursive: true });
@@ -63927,37 +63956,6 @@ function attachDiagnosticListeners(p2) {
     } catch {
     }
   });
-  if (!initScriptInstalled) {
-    try {
-      p2.addInitScript(`(() => {
-        if (window.__browserEvents) return;
-        window.__browserEvents = [];
-        const push = (evt) => {
-          window.__browserEvents.push(evt);
-          if (window.__browserEvents.length > 2000) window.__browserEvents.splice(0, window.__browserEvents.length - 2000);
-        };
-        const origError = console.error;
-        console.error = function() {
-          push({ ts: Date.now(), type: "console:error", text: Array.from(arguments).map(String).join(" ").slice(0, 2000) });
-          return origError.apply(console, arguments);
-        };
-        const origWarn = console.warn;
-        console.warn = function() {
-          push({ ts: Date.now(), type: "console:warn", text: Array.from(arguments).map(String).join(" ").slice(0, 2000) });
-          return origWarn.apply(console, arguments);
-        };
-        window.onerror = function(msg, source, lineno, colno, err) {
-          push({ ts: Date.now(), type: "onerror", text: String(msg).slice(0, 2000), stack: err instanceof Error ? (err.stack || "").slice(0, 3000) : "" });
-        };
-        window.onunhandledrejection = function(evt) {
-          const r = evt.reason;
-          push({ ts: Date.now(), type: "unhandledRejection", text: String(r?.message ?? r ?? "unknown").slice(0, 2000), stack: typeof r?.stack === "string" ? r.stack.slice(0, 3000) : "" });
-        };
-      })()`);
-      initScriptInstalled = true;
-    } catch {
-    }
-  }
 }
 function clearDiagnosticBuffers() {
   consoleBuffer = [];
@@ -64145,6 +64143,9 @@ async function runBrowserLocatorAction(pageHandle, selector, index, timeout2, ac
 async function waitForBrowserExpectation(pageHandle, expectation, timeout2) {
   await pageHandle.locator(expectation).first().waitFor({ state: "visible", timeout: timeout2 });
 }
+async function browserExpectationIsVisible(pageHandle, expectation) {
+  return Boolean(await pageHandle.locator(expectation).first().isVisible().catch(() => false));
+}
 async function runBrowserInteractionWithEvidence(input) {
   const before = await captureBrowserInteractionSnapshot(input.pageHandle);
   let performed = null;
@@ -64736,6 +64737,169 @@ async function findBrowserVisualCandidate(pageHandle, target, visualX, visualY,
   }
   return candidates.filter((candidate) => includeOffscreen || candidate["visible"] === true).sort((a2, b) => Number(b["score"] ?? 0) - Number(a2["score"] ?? 0))[0] ?? null;
 }
+async function captureBrowserObservation(input) {
+  const html = await input.pageHandle.content();
+  const readableText = await input.pageHandle.evaluate(`(() => {
+    const clone = document.body ? document.body.cloneNode(true) : document.documentElement.cloneNode(true);
+    clone.querySelectorAll("script, style, noscript, svg, path").forEach(el => el.remove());
+    return clone.innerText || clone.textContent || "";
+  })()`);
+  const summary = downsampleDom(html);
+  lastDomSummarySelectors = extractDomSummarySelectors(summary);
+  const screenshotBuffer = await input.pageHandle.screenshot({
+    fullPage: input.fullPage
+  });
+  const screenshotPath = saveBuffer(input.outputPath || defaultArtifactPath(input.action, "png"), screenshotBuffer);
+  const viewport = input.pageHandle.viewportSize?.() ?? {
+    width: 0,
+    height: 0
+  };
+  const diagnostics = input.cursor ? browserDiagnosticWindow(input.cursor) : {
+    startedAtMs: input.startMs,
+    endedAtMs: Date.now(),
+    console: [...consoleBuffer],
+    network: [...networkBuffer],
+    errors: [...errorBuffer],
+    websockets: [...wsBuffer],
+    crashCount
+  };
+  const consoleErrors = diagnostics.console.filter((entry) => /error/i.test(entry.type)).slice(-30);
+  const consoleWarnings = diagnostics.console.filter((entry) => /warn/i.test(entry.type)).slice(-30);
+  const networkFailures = diagnostics.network.filter((entry) => entry.ok === false || (entry.status ?? 0) >= 400).slice(-30);
+  const pageErrors = diagnostics.errors.slice(-30);
+  const gate = classifyBrowserGate({
+    url: input.pageHandle.url(),
+    html,
+    text: String(readableText ?? ""),
+    network: diagnostics.network,
+    errors: diagnostics.errors
+  });
+  const actualObservationMs = Math.max(0, diagnostics.endedAtMs - diagnostics.startedAtMs);
+  const runtimeFailureCount = consoleErrors.length + pageErrors.length + networkFailures.length + diagnostics.crashCount;
+  const blocked = gate.kind === "captcha" || gate.kind === "bot_challenge";
+  const contradicted = input.expectationSatisfied === false || runtimeFailureCount > 0;
+  const verification = blocked ? {
+    status: "blocked",
+    confidence: gate.confidence,
+    reason: `Browser observation was blocked by gate=${gate.kind}.`
+  } : contradicted ? {
+    status: "contradicted",
+    confidence: 0.96,
+    reason: input.expectationSatisfied === false ? `The declared postcondition was not observed: ${input.expectation}.` : `The browser emitted ${runtimeFailureCount} runtime failure signal(s) during the observation window.`,
+    nextSuggestedObservation: "Fix the concrete console/page/network failure, then rerun validate_lifecycle or observe_window in the same browser mode."
+  } : input.expectationSatisfied === true ? {
+    status: "proven",
+    confidence: 0.9,
+    reason: `The declared postcondition remained visible and no browser runtime failures appeared during the ${actualObservationMs}ms observation window.`
+  } : {
+    status: "inconclusive",
+    confidence: 0.58,
+    reason: `The browser remained under observation for ${actualObservationMs}ms, but no explicit postcondition was evaluated.`,
+    nextSuggestedObservation: "Repeat with expect set to a state-specific selector before making a user-visible success claim."
+  };
+  const mode = browserHeadless === false ? "headed" : "headless";
+  const evidenceEvent = createEvidenceEvent({
+    sessionId: playwrightSessionId ?? void 0,
+    tool: "playwright_browser",
+    action: input.action,
+    surface: "browser",
+    claim: input.expectation ? `Browser postcondition: ${input.expectation}` : "Timed browser runtime observation",
+    after: createEvidenceObservation({
+      screenshotPath,
+      screenshotHash: sha256Buffer(screenshotBuffer),
+      width: viewport.width,
+      height: viewport.height,
+      url: input.pageHandle.url(),
+      title: await input.pageHandle.title(),
+      domSummaryHash: sha256Text(summary),
+      readableTextHash: sha256Text(String(readableText ?? "")),
+      visibleTextExcerpt: clipEvidenceText(readableText, 500),
+      consoleErrorCount: consoleErrors.length,
+      pageErrorCount: pageErrors.length,
+      networkFailureCount: networkFailures.length,
+      gateKind: gate.kind,
+      gateConfidence: gate.confidence,
+      gateEvidence: gate.evidence,
+      metadata: {
+        mode,
+        engine: "playwright",
+        requestedObservationMs: input.requestedObservationMs,
+        actualObservationMs,
+        diagnosticsScope: input.cursor ? "window" : "session",
+        consoleWarningCount: consoleWarnings.length,
+        websocketEventCount: diagnostics.websockets.length,
+        crashCount: diagnostics.crashCount,
+        expectation: input.expectation,
+        expectationSatisfied: input.expectationSatisfied
+      }
+    }),
+    verification
+  });
+  const bundle = {
+    schema: "omnius.browser-observation-window.v1",
+    id: timestampSlug(),
+    engine: "playwright",
+    mode,
+    url: input.pageHandle.url(),
+    title: await input.pageHandle.title(),
+    viewport,
+    screenshotPath,
+    observationWindow: {
+      requestedMs: input.requestedObservationMs,
+      actualMs: actualObservationMs,
+      startedAt: new Date(diagnostics.startedAtMs).toISOString(),
+      endedAt: new Date(diagnostics.endedAtMs).toISOString(),
+      diagnosticsScope: input.cursor ? "window" : "session"
+    },
+    expectation: input.expectation ?? null,
+    expectationSatisfied: input.expectationSatisfied ?? null,
+    expectationError: input.expectationError ?? null,
+    gate,
+    consoleErrors,
+    consoleWarnings,
+    networkFailures,
+    pageErrors,
+    websocketEvents: diagnostics.websockets.slice(-30),
+    crashes: diagnostics.crashCount,
+    domSummary: summary.slice(0, 12e3),
+    evidenceEvents: [evidenceEvent]
+  };
+  const failureDetails = [
+    ...consoleErrors.map((entry) => `console ${entry.type}: ${entry.text}${entry.loc ? ` (${entry.loc})` : ""}`),
+    ...pageErrors.map((entry) => `page error: ${entry.message}`),
+    ...networkFailures.map((entry) => `network: ${entry.method} ${entry.status ?? "FAILED"} ${entry.url}${entry.failure ? ` (${entry.failure})` : ""}`)
+  ].slice(0, 30);
+  const output2 = [
+    "Browser observation bundle",
+    `URL: ${bundle.url}`,
+    `Title: ${bundle.title}`,
+    `Mode: ${mode}`,
+    `Observation window: ${actualObservationMs}ms (${input.cursor ? "window-scoped" : "session-scoped"} diagnostics)`,
+    `Viewport: ${viewport.width}x${viewport.height}`,
+    `Screenshot: ${screenshotPath}`,
+    `Gate: ${gate.kind} (${gate.confidence.toFixed(2)})${gate.evidence.length ? ` — ${gate.evidence.join("; ")}` : ""}`,
+    `Console errors: ${consoleErrors.length}`,
+    `Console warnings: ${consoleWarnings.length}`,
+    `Page errors: ${pageErrors.length}`,
+    `Network failures: ${networkFailures.length}`,
+    `Verification: ${verification.status} — ${verification.reason}`,
+    ...failureDetails.length > 0 ? ["", "--- Runtime failures ---", ...failureDetails] : [],
+    "",
+    "--- DOM Summary ---",
+    summary.slice(0, 6e3)
+  ].join("\n");
+  const shouldFail = input.failOnRuntimeErrors && contradicted;
+  return {
+    success: !shouldFail,
+    output: output2,
+    ...shouldFail ? {
+      error: `Browser lifecycle validation failed: ${runtimeFailureCount} runtime failure signal(s)${input.expectationSatisfied === false ? "; declared postcondition was not observed" : ""}.`
+    } : {},
+    llmContent: JSON.stringify(bundle, null, 2),
+    evidenceEvents: [evidenceEvent],
+    durationMs: Date.now() - input.startMs
+  };
+}
 function ok(output2, start2, skipDiag = false) {
   const diag = skipDiag ? "" : formatDiagnosticSummary();
   return {
@@ -64748,7 +64912,7 @@ ${diag}` : output2,
 function fail(error, start2) {
   return { success: false, output: "", error, durationMs: Date.now() - start2 };
 }
-var pw, browser, context, page, browserHeadless, playwrightSessionId, playwrightSessionSequence, MAX_BUFFER, consoleBuffer, networkBuffer, errorBuffer, wsBuffer, crashCount, initScriptInstalled, lastDomSummarySelectors, dynamicImport, PLAYWRIGHT_RUNTIME_DIR, PLAYWRIGHT_BROWSERS_DIR, PLAYWRIGHT_CHROMIUM_INSTALL_ARGS, PlaywrightBrowserTool;
+var pw, browser, context, page, browserHeadless, playwrightSessionId, playwrightSessionSequence, MAX_BUFFER, consoleBuffer, networkBuffer, errorBuffer, wsBuffer, crashCount, lastDomSummarySelectors, dynamicImport, PLAYWRIGHT_RUNTIME_DIR, PLAYWRIGHT_BROWSERS_DIR, PLAYWRIGHT_CHROMIUM_INSTALL_ARGS, PlaywrightBrowserTool;
 var init_playwright_browser = __esm({
   "packages/execution/dist/tools/playwright-browser.js"() {
     "use strict";
@@ -64769,15 +64933,18 @@ var init_playwright_browser = __esm({
     errorBuffer = [];
     wsBuffer = [];
     crashCount = 0;
-    initScriptInstalled = false;
     lastDomSummarySelectors = /* @__PURE__ */ new Map();
-    dynamicImport = new Function("mod", "return import(mod)");
+    dynamicImport = (mod3) => import(
+      /* @vite-ignore */
+      mod3
+    );
     PLAYWRIGHT_RUNTIME_DIR = join22(homedir7(), ".omnius", "playwright-runtime");
     PLAYWRIGHT_BROWSERS_DIR = join22(PLAYWRIGHT_RUNTIME_DIR, "browsers");
     PLAYWRIGHT_CHROMIUM_INSTALL_ARGS = ["playwright", "install", "chromium"];
     PlaywrightBrowserTool = class {
       name = "playwright_browser";
-      description = "Full-scope Playwright browser automation + diagnostic capture. Launches a persistent headless Chromium session by default, with optional visible/headed mode when a GUI display is available. Beyond navigation/interaction, this tool buffers everything the running app emits (console messages, network requests, JS exceptions, accessibility tree) so the agent can verify what is ACTUALLY happening — not just what the build/test reports. Auto-installs Playwright + Chromium on first use without sudo or OS package manager escalation. Diagnostic actions: observe_bundle, dom_summary, dom, console_logs, network_log, page_errors, websocket_log, a11y_snapshot, bounding_box, query_all, performance, cookies, storage, viewport, clear_diagnostics. Interaction actions: navigate, click, visual_click, fill, type, press, select, check, hover. Use fill with a selector or natural-language target for form fields; avoid raw evaluate for form filling because direct .value assignment does not fire app input/change events. For state-changing interactions, pass expect as a Playwright selector for the visible post-action state (for example text=Stop Simulation). A dispatched click without an asserted postcondition is recorded as inconclusive, not completion proof. Selectors are strict by default: when a selector matches more than one element, use a more specific selector or index (zero-based). Detached/re-rendered elements are re-queried once before failing. This is a separate browser/runtime from browser_action; once you start a workflow here, continue here unless you intentionally navigate browser_action to the same URL. Every result carries a typed runtime-session receipt; use hardware_prerequisite before declaring a WebSerial, WebUSB, camera, or microphone interaction blocked by a real device/permission boundary. Capture actions: screenshot, pdf, content, innerText, innerHTML, getAttribute, evaluate. Loopback URLs (localhost, 127.0.0.1, ::1) are allowed for local development servers; private LAN and metadata URLs remain blocked. Workflow for user-facing work: start/serve the system with the stack-native tool, navigate to the real URL, then inspect page_errors, console_logs, network_log, DOM/accessibility, and screenshot evidence before completion. Build/typecheck/test output is only one layer; runtime browser evidence is required when the delivered artifact is a page, app, dashboard, game, form, visualization, or other UI. Repeat navigate/act/observe until the actual user flow is clean.";
+      modelFacingSummary = "Validate a live UI in one persistent Playwright session. For GUI, GPU, WebGL, WebGPU, canvas, or animation claims, use validate_lifecycle with headless=false, force_new=true, an explicit expect, and a finite observation_ms. Use observe_window after interactions. Inspect delayed console, page, network, DOM, and screenshot evidence. A clean headless or immediate load is not headed lifecycle proof.";
+      description = "Persistent Playwright browser lifecycle validation with timed console, page-error, network, DOM, and screenshot capture. Launches a persistent headless Chromium session by default, with optional visible/headed mode when a GUI display is available. Beyond navigation/interaction, this tool buffers everything the running app emits (console messages, network requests, JS exceptions, accessibility tree) so the agent can verify what is ACTUALLY happening — not just what the build/test reports. Auto-installs Playwright + Chromium on first use without sudo or OS package manager escalation. Diagnostic actions: validate_lifecycle, observe_window, observe_bundle, dom_summary, dom, console_logs, network_log, page_errors, websocket_log, a11y_snapshot, bounding_box, query_all, performance, cookies, storage, viewport, clear_diagnostics. Interaction actions: navigate, click, visual_click, fill, type, press, select, check, hover. Use fill with a selector or natural-language target for form fields; avoid raw evaluate for form filling because direct .value assignment does not fire app input/change events. For state-changing interactions, pass expect as a Playwright selector for the visible post-action state (for example text=Stop Simulation). A dispatched click without an asserted postcondition is recorded as inconclusive, not completion proof. Selectors are strict by default: when a selector matches more than one element, use a more specific selector or index (zero-based). Detached/re-rendered elements are re-queried once before failing. This is a separate browser/runtime from browser_action; once you start a workflow here, continue here unless you intentionally navigate browser_action to the same URL. Every result carries a typed runtime-session receipt; use hardware_prerequisite before declaring a WebSerial, WebUSB, camera, or microphone interaction blocked by a real device/permission boundary. Capture actions: screenshot, pdf, content, innerText, innerHTML, getAttribute, evaluate. Loopback URLs (localhost, 127.0.0.1, ::1) are allowed for local development servers; private LAN and metadata URLs remain blocked. Workflow for user-facing work: start/serve the system with the stack-native tool, then run validate_lifecycle against the real URL with an explicit expect and observation_ms. For GPU, WebGL, WebGPU, canvas, animation, or failures seen in a normal GUI browser, use headless=false and force_new=true; a clean headless run does not verify headed GPU behavior. Use observe_window after interactions to keep the same browser alive while delayed failures surface, then inspect page_errors, console_logs, network_log, DOM/accessibility, and screenshot evidence before completion. Build/typecheck/test output is only one layer; runtime browser evidence is required when the delivered artifact is a page, app, dashboard, game, form, visualization, or other UI. Repeat navigate/act/observe until the actual user flow is clean.";
       parameters = {
         type: "object",
         properties: {
@@ -64824,12 +64991,14 @@ var init_playwright_browser = __esm({
               "storage",
               "viewport",
               "observe_bundle",
+              "observe_window",
+              "validate_lifecycle",
               "visual_click",
               "hardware_prerequisite",
               "clear_diagnostics",
               "close"
             ],
-            description: "Action to perform:\n- navigate: go to a URL\n- click: click element by selector\n- fill: clear input and type text by selector, or by natural-language target when selector is absent\n- type: type text character by character into a selector, or into the currently focused element after visual_click\n- press: press a key (Enter, Tab, Escape, etc.)\n- screenshot: capture the headless browser page, not the desktop; use value to choose the output file path\n- observe_bundle: capture URL/title/viewport, DOM summary, a11y, diagnostics, screenshot, and gate assessment\n- visual_click: browser screenshot -> Moondream point -> elementFromPoint -> human-like Playwright mouse click -> post-action screenshot\n- hardware_prerequisite: record whether a WebSerial/WebUSB/media flow has the browser capability, secure context, and required physical/user-gesture prerequisite; it never pretends hardware was exercised\n- evaluate: run JavaScript in page context\n- content: get page text content (readable, stripped)\n- dom: get raw page HTML (truncated)\n- dom_summary: compact interactive DOM summary with selectors\n- innerText: get innerText of a specific element\n- select: select dropdown option by value\n- check/uncheck: toggle checkbox\n- hover: hover over element\n- wait: wait for a selector to appear, or sleep for timeout ms when no selector is provided\n- waitForNavigation: wait for page navigation to complete\n- waitForSelector: wait for element matching selector\n- title: get page title\n- url: get current URL\n- getAttribute: get element attribute value\n- innerHTML: get element's innerHTML\n- textContent: get element's textContent\n- goBack/goForward/reload: browser navigation\n- pdf: save page as PDF\n- close: close browser session"
+            description: "Action to perform:\n- navigate: go to a URL\n- click: click element by selector\n- fill: clear input and type text by selector, or by natural-language target when selector is absent\n- type: type text character by character into a selector, or into the currently focused element after visual_click\n- press: press a key (Enter, Tab, Escape, etc.)\n- screenshot: capture the headless browser page, not the desktop; use value to choose the output file path\n- observe_bundle: capture URL/title/viewport, DOM summary, a11y, diagnostics, screenshot, and gate assessment\n- observe_window: keep the current browser/page alive for observation_ms, then return only diagnostics emitted during that time window plus DOM/screenshot evidence\n- validate_lifecycle: start a fresh headed browser by default, clear diagnostics, navigate to url, hold it for observation_ms, and fail on delayed console/page/network errors; use this for GUI/GPU/WebGL validation\n- visual_click: browser screenshot -> Moondream point -> elementFromPoint -> human-like Playwright mouse click -> post-action screenshot\n- hardware_prerequisite: record whether a WebSerial/WebUSB/media flow has the browser capability, secure context, and required physical/user-gesture prerequisite; it never pretends hardware was exercised\n- evaluate: run JavaScript in page context\n- content: get page text content (readable, stripped)\n- dom: get raw page HTML (truncated)\n- dom_summary: compact interactive DOM summary with selectors\n- innerText: get innerText of a specific element\n- select: select dropdown option by value\n- check/uncheck: toggle checkbox\n- hover: hover over element\n- wait: wait for a selector to appear, or sleep for timeout ms when no selector is provided\n- waitForNavigation: wait for page navigation to complete\n- waitForSelector: wait for element matching selector\n- title: get page title\n- url: get current URL\n- getAttribute: get element attribute value\n- innerHTML: get element's innerHTML\n- textContent: get element's textContent\n- goBack/goForward/reload: browser navigation\n- pdf: save page as PDF\n- close: close browser session"
           },
           url: {
             type: "string",
@@ -64895,6 +65064,14 @@ var init_playwright_browser = __esm({
             type: "number",
             description: "Milliseconds to wait for expect after the action (defaults to timeout)."
           },
+          observation_ms: {
+            type: "number",
+            description: "Milliseconds to keep the instantiated page alive while collecting delayed diagnostics. Defaults to 8000 for validate_lifecycle and 5000 for observe_window; maximum 120000."
+          },
+          start_delay_ms: {
+            type: "number",
+            description: "Optional delay before opening an observe_window diagnostic window. Use this only when the requested lifecycle has an explicit warm-up phase; maximum 60000."
+          },
           hardware_capability: {
             type: "string",
             enum: ["web_serial", "web_usb", "camera", "microphone"],
@@ -64906,7 +65083,7 @@ var init_playwright_browser = __esm({
           },
           headless: {
             type: "boolean",
-            description: "Launch mode for a new browser session. Defaults to true. Set false to use a visible GUI Chromium when DISPLAY/desktop access is available; changing this restarts the browser session."
+            description: "Launch mode for a new browser session. Normal actions default to true; validate_lifecycle defaults to false. For GUI/GPU/WebGL claims, set false explicitly. A headless result cannot verify headed graphics behavior."
           },
           force_new: {
             type: "boolean",
@@ -64948,8 +65125,12 @@ var init_playwright_browser = __esm({
         const expectationTimeout = typeof args.expect_timeout === "number" ? Math.max(1, Math.min(12e4, Math.round(args.expect_timeout))) : timeout2;
         const width = typeof args.width === "number" ? Math.max(320, Math.min(3840, Math.round(args.width))) : void 0;
         const height = typeof args.height === "number" ? Math.max(240, Math.min(2160, Math.round(args.height))) : void 0;
-        const headless = asOptionalBoolean(args.headless);
-        const forceNew = asOptionalBoolean(args.force_new) === true;
+        const requestedHeadless = asOptionalBoolean(args.headless);
+        const validatesFullLifecycle = action === "validate_lifecycle";
+        const headless = requestedHeadless ?? (validatesFullLifecycle ? false : void 0);
+        const forceNew = asOptionalBoolean(args.force_new) === true || validatesFullLifecycle;
+        const observationMs = typeof args.observation_ms === "number" ? Math.max(0, Math.min(12e4, Math.round(args.observation_ms))) : validatesFullLifecycle ? 8e3 : 5e3;
+        const startDelayMs = typeof args.start_delay_ms === "number" ? Math.max(0, Math.min(6e4, Math.round(args.start_delay_ms))) : 0;
         const visualTarget = typeof args.target === "string" && args.target.trim() ? args.target.trim() : typeof args.text === "string" && args.text.trim() ? args.text.trim() : "";
         const preferredVisionModel = normalizeVisionModelName(args.vision_model);
         const delayMs = typeof args.delay_ms === "number" ? Math.max(0, Math.min(3e4, Math.round(args.delay_ms))) : 700;
@@ -64964,6 +65145,9 @@ var init_playwright_browser = __esm({
             durationMs: Date.now() - start2
           };
         }
+        if (headless === false && !hasGraphicalBrowserDisplay()) {
+          return fail("Headed Chromium was required, but no graphical DISPLAY or WAYLAND_DISPLAY is available. Report headed GUI/GPU validation as blocked; do not substitute a clean headless run.", start2);
+        }
         const err = await ensureBrowser({ headless, forceNew });
         if (err)
           return {
@@ -65689,7 +65873,14 @@ ${JSON.stringify(data, null, 2)}`, start2);
               }
               return fail(`viewport: provide "WxH" (e.g. "375x667") or a Playwright device name (e.g. "iPhone 13")`, start2);
             }
-            case "observe_bundle": {
+            case "validate_lifecycle": {
+              if (!url)
+                return fail("url is required", start2);
+              try {
+                await validateNetworkEgressUrl(url, { allowLoopback: true });
+              } catch (err2) {
+                return fail(networkEgressErrorMessage(err2), start2);
+              }
               if (width || height) {
                 const current = page.viewportSize?.() ?? {
                   width: 1280,
@@ -65700,87 +65891,107 @@ ${JSON.stringify(data, null, 2)}`, start2);
                   height: height ?? current.height ?? 720
                 });
               }
-              const html = await page.content();
-              const readableText = await page.evaluate(`(() => {
-            const clone = document.body ? document.body.cloneNode(true) : document.documentElement.cloneNode(true);
-            clone.querySelectorAll("script, style, noscript, svg, path").forEach(el => el.remove());
-            return clone.innerText || clone.textContent || "";
-          })()`);
-              const summary = downsampleDom(html);
-              lastDomSummarySelectors = extractDomSummarySelectors(summary);
-              const screenshotPath = saveBuffer(outputPath3 || defaultArtifactPath("observe", "png"), await page.screenshot({ fullPage: args.full_page === true }));
-              const viewport = page.viewportSize?.() ?? { width: 0, height: 0 };
-              const gate = classifyBrowserGate({
-                url: page.url(),
-                html,
-                text: String(readableText ?? ""),
-                network: networkBuffer,
-                errors: errorBuffer
+              clearDiagnosticBuffers();
+              const cursor = captureBrowserDiagnosticCursor();
+              await page.goto(url, {
+                waitUntil: "domcontentloaded",
+                timeout: timeout2
               });
-              const errors = errorBuffer.slice(-20).map((entry) => entry.message);
-              const networkFailures = networkBuffer.filter((entry) => entry.ok === false || (entry.status ?? 0) >= 400).slice(-30).map((entry) => `${entry.method} ${entry.status ?? "FAILED"} ${entry.url}${entry.failure ? ` (${entry.failure})` : ""}`);
-              const bundle = {
-                id: timestampSlug(),
-                engine: "playwright",
-                mode: browserHeadless === false ? "headed" : "headless",
-                url: page.url(),
-                title: await page.title(),
-                viewport,
-                screenshotPath,
-                gate,
-                consoleErrors: consoleBuffer.filter((entry) => /error|warning/i.test(entry.type)).slice(-20),
-                networkFailures,
-                pageErrors: errors,
-                domSummary: summary.slice(0, 12e3)
-              };
-              const evidenceEvent = createEvidenceEvent({
-                tool: "playwright_browser",
+              let expectationSatisfied;
+              let expectationError;
+              const expectationProbe = expectation ? waitForBrowserExpectation(page, expectation, Math.min(expectationTimeout, Math.max(1, observationMs))).then(() => {
+                expectationSatisfied = true;
+              }).catch((err2) => {
+                expectationSatisfied = false;
+                expectationError = err2 instanceof Error ? err2.message : String(err2);
+              }) : Promise.resolve();
+              await Promise.all([
+                page.waitForTimeout(observationMs),
+                expectationProbe
+              ]);
+              if (expectation && expectationSatisfied === true && !await browserExpectationIsVisible(page, expectation)) {
+                expectationSatisfied = false;
+                expectationError = "The declared postcondition was visible during the window but was not visible at the end of it.";
+              }
+              return captureBrowserObservation({
+                pageHandle: page,
+                action: "validate_lifecycle",
+                startMs: start2,
+                outputPath: outputPath3,
+                fullPage: args.full_page === true,
+                cursor,
+                requestedObservationMs: observationMs,
+                expectation,
+                expectationSatisfied,
+                expectationError,
+                failOnRuntimeErrors: true
+              });
+            }
+            case "observe_window": {
+              if (startDelayMs > 0)
+                await page.waitForTimeout(startDelayMs);
+              if (width || height) {
+                const current = page.viewportSize?.() ?? {
+                  width: 1280,
+                  height: 720
+                };
+                await page.setViewportSize({
+                  width: width ?? current.width ?? 1280,
+                  height: height ?? current.height ?? 720
+                });
+              }
+              const cursor = captureBrowserDiagnosticCursor();
+              let expectationSatisfied;
+              let expectationError;
+              const expectationProbe = expectation ? waitForBrowserExpectation(page, expectation, Math.min(expectationTimeout, Math.max(1, observationMs))).then(() => {
+                expectationSatisfied = true;
+              }).catch((err2) => {
+                expectationSatisfied = false;
+                expectationError = err2 instanceof Error ? err2.message : String(err2);
+              }) : Promise.resolve();
+              await Promise.all([
+                page.waitForTimeout(observationMs),
+                expectationProbe
+              ]);
+              if (expectation && expectationSatisfied === true && !await browserExpectationIsVisible(page, expectation)) {
+                expectationSatisfied = false;
+                expectationError = "The declared postcondition was visible during the window but was not visible at the end of it.";
+              }
+              return captureBrowserObservation({
+                pageHandle: page,
+                action: "observe_window",
+                startMs: start2,
+                outputPath: outputPath3,
+                fullPage: args.full_page === true,
+                cursor,
+                requestedObservationMs: observationMs,
+                expectation,
+                expectationSatisfied,
+                expectationError,
+                failOnRuntimeErrors: true
+              });
+            }
+            case "observe_bundle": {
+              if (width || height) {
+                const current = page.viewportSize?.() ?? {
+                  width: 1280,
+                  height: 720
+                };
+                await page.setViewportSize({
+                  width: width ?? current.width ?? 1280,
+                  height: height ?? current.height ?? 720
+                });
+              }
+              return captureBrowserObservation({
+                pageHandle: page,
                 action: "observe_bundle",
-                surface: "browser",
-                after: createEvidenceObservation({
-                  screenshotPath,
-                  width: viewport.width,
-                  height: viewport.height,
-                  url: bundle.url,
-                  title: bundle.title,
-                  domSummaryHash: sha256Text(summary),
-                  readableTextHash: sha256Text(String(readableText ?? "")),
-                  visibleTextExcerpt: clipEvidenceText(readableText, 500),
-                  consoleErrorCount: bundle.consoleErrors.length,
-                  pageErrorCount: errors.length,
-                  networkFailureCount: networkFailures.length,
-                  gateKind: gate.kind,
-                  gateConfidence: gate.confidence,
-                  gateEvidence: gate.evidence,
-                  metadata: { mode: bundle.mode, engine: "playwright" }
-                }),
-                verification: {
-                  status: gate.kind === "captcha" || gate.kind === "bot_challenge" ? "blocked" : "inconclusive",
-                  confidence: gate.kind === "captcha" || gate.kind === "bot_challenge" ? gate.confidence : 0.5,
-                  reason: gate.kind === "none" ? "Fresh browser observation captured; no specific completion claim was evaluated." : `Fresh browser observation captured with gate=${gate.kind}.`
-                }
+                startMs: start2,
+                outputPath: outputPath3,
+                fullPage: args.full_page === true,
+                requestedObservationMs: 0,
+                expectation,
+                failOnRuntimeErrors: false
               });
-              const modelBundle = { ...bundle, evidenceEvents: [evidenceEvent] };
-              return {
-                success: true,
-                output: [
-                  "Browser observation bundle",
-                  `URL: ${bundle.url}`,
-                  `Title: ${bundle.title}`,
-                  `Mode: ${bundle.mode}`,
-                  `Viewport: ${viewport.width}x${viewport.height}`,
-                  `Screenshot: ${screenshotPath}`,
-                  `Gate: ${gate.kind} (${gate.confidence.toFixed(2)})${gate.evidence.length ? ` — ${gate.evidence.join("; ")}` : ""}`,
-                  `Console warnings/errors: ${bundle.consoleErrors.length}`,
-                  `Network failures: ${networkFailures.length}`,
-                  "",
-                  "--- DOM Summary ---",
-                  summary.slice(0, 6e3)
-                ].join("\n"),
-                llmContent: JSON.stringify(modelBundle, null, 2),
-                evidenceEvents: [evidenceEvent],
-                durationMs: Date.now() - start2
-              };
             }
             case "visual_click": {
               if (!visualTarget)
@@ -66068,7 +66279,9 @@ ${JSON.stringify(data, null, 2)}`, start2);
                 ].filter(Boolean).join("\n"),
                 llmContent: JSON.stringify(bundle, null, 2),
                 evidenceEvents: [evidenceEvent],
-                ...expectationSatisfied === false ? { error: `Postcondition not observed: ${expectation}. ${expectationError?.slice(0, 500) ?? ""}`.trim() } : {},
+                ...expectationSatisfied === false ? {
+                  error: `Postcondition not observed: ${expectation}. ${expectationError?.slice(0, 500) ?? ""}`.trim()
+                } : {},
                 durationMs: Date.now() - start2
               };
             }
@@ -659396,13 +659609,13 @@ ${context2 ?? ""}`;
               critique2 = this._buildVisualAdversaryCritique({
                 evidence: `${inconclusiveEvent.tool}/${inconclusiveEvent.action} produced only inconclusive proof: ${inconclusiveEvent.verification?.reason ?? "no reason"}`,
                 hypothesis: "The browser action may have worked, but the current evidence is not strong enough to prove the user-visible event.",
-                correctiveAction: 'Run playwright_browser({action:"observe_bundle"}) after the action and verify URL, visible text, DOM, console, network, and gate state.'
+                correctiveAction: 'Run playwright_browser({action:"observe_window", observation_ms:5000, expect:"..."}) after the action. Verify the expected state plus window-scoped console, page, network, DOM, and screenshot evidence.'
               });
             } else if (events.length === 0) {
               critique2 = this._buildVisualAdversaryCritique({
                 evidence: `${toolName} changed ${surface} state but did not return a structured evidence event.`,
                 hypothesis: "The agent may be acting from stale visual state after a click/type/submit/navigation action.",
-                correctiveAction: surface === "browser" ? 'Run playwright_browser({action:"observe_bundle"}) or a post-action screenshot/DOM check before claiming success.' : 'Run vision_action_loop({action:"observe", goal:"..."}) or desktop_describe before claiming success.'
+                correctiveAction: surface === "browser" ? 'Run playwright_browser({action:"observe_window", observation_ms:5000, expect:"..."}) before claiming success. Use a fresh headed validate_lifecycle run when the claim concerns GUI, GPU, WebGL, WebGPU, canvas, or animation behavior.' : 'Run vision_action_loop({action:"observe", goal:"..."}) or desktop_describe before claiming success.'
               });
             }
             if (critique2) {
@@ -678995,6 +679208,9 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
           "file_explore",
           "web_search",
           "web_fetch",
+          // Browser evidence must be available without a lexical relevance guess.
+          // Surfaces that do not register this tool do not expose it.
+          "playwright_browser",
           "memory_read",
           "memory_write",
           "working_notes",
@@ -679112,11 +679328,12 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
         const compressDesc = true;
         const defs = dedupedInline.map((tool) => {
           const desc = getDesc(tool);
+          const modelFacingDescription = tool.modelFacingSummary?.trim();
           return {
             type: "function",
             function: {
               name: tool.name,
-              description: compressDesc ? (desc.split(/\.\s/)[0]?.slice(0, 120) ?? desc.slice(0, 120)) + "." : desc,
+              description: modelFacingDescription ? modelFacingDescription.slice(0, 420) : compressDesc ? (desc.split(/\.\s/)[0]?.slice(0, 120) ?? desc.slice(0, 120)) + "." : desc,
               parameters: this._publicToolParameters(tool.parameters)
             }
           };
@@ -686617,11 +686834,11 @@ var init_workerSkillStandard = __esm({
         {
           stepNumber: 3,
           title: "Validate every requested browser flow in one Playwright session",
-          description: "Use playwright_browser navigate -> observe_bundle -> action -> state-based postcondition -> observe_bundle. Prefer data-testid or role/name locators. A click receipt or screenshot alone is not a pass. Re-query after a detached-element error; record each requested interaction as passed, failed, blocked, not_applicable, or inconclusive with the concrete state and diagnostics.",
+          description: "Use playwright_browser validate_lifecycle -> action -> state-based postcondition -> observe_window. Set a finite observation_ms so delayed errors can surface. For GUI, GPU, WebGL, WebGPU, canvas, or animation claims, use a fresh headed browser. A clean headless load is not headed rendering evidence. Prefer data-testid or role/name locators. A click receipt or screenshot alone is not a pass. Re-query after a detached-element error; record each requested interaction as passed, failed, blocked, not_applicable, or inconclusive with the concrete state and diagnostics.",
           tools: ["playwright_browser"],
           skills: ["browser-interaction-validation"],
           output: "One claim-scoped browser evidence entry per requested interaction, separate from static test evidence",
-          verification: "Every interaction has an observed postcondition or a precise failed/blocked/not-applicable outcome; page errors, console errors, and failed network requests are reviewed"
+          verification: "Every interaction has an observed postcondition or a precise failed/blocked/not-applicable outcome; delayed page errors, console errors, failed network requests, DOM state, and screenshots are reviewed from the relevant observation window"
         },
         {
           stepNumber: 4,
@@ -692429,10 +692646,12 @@ FOR SCREEN / DESKTOP UI (what is on this computer display, clicking, navigating)
   desktop_click({ target: "element" })  - Click a UI element by description.
   vision_action_loop({ goal: "task", action: "observe" })  - Persistent screenshot/OCR/point/action loop with previewable screenshots.
 
-FOR BROWSER PAGE / WEB GUI RENDERS (headless, deterministic viewport):
+FOR BROWSER PAGE / WEB GUI RENDERS:
   browser_action({ action: "screenshot", width: 1280, height: 720, output_path: ".omnius/browser/page.png" })  - Render the current headless browser page and return an image input.
   playwright_browser({ action: "viewport", text: "1280x720" }) then playwright_browser({ action: "screenshot", value: ".omnius/browser/page.png" })  - Playwright diagnostic browser capture.
-  playwright_browser({ action: "observe_bundle" })  - Capture screenshot + DOM summary + diagnostics + gate assessment in one browser observation.
+  playwright_browser({ action: "validate_lifecycle", url: "http://127.0.0.1:3000", headless: false, force_new: true, observation_ms: 8000, expect: "text=Ready" })  - Start diagnostics before navigation and hold a fresh GUI browser open for delayed rendering failures.
+  playwright_browser({ action: "observe_window", observation_ms: 5000, expect: "text=Updated" })  - Keep the current page alive and return diagnostics emitted during the post-action window.
+  playwright_browser({ action: "observe_bundle" })  - Capture current session diagnostics and page state when a timed window is not required.
   playwright_browser({ action: "visual_click", target: "button or field", vision_model: "moondream" })  - Browser screenshot -> Moondream point -> DOM candidate -> click -> post-action screenshot.
 
 RULES:
@@ -692441,6 +692660,7 @@ RULES:
   - For seeing the screen, use screenshot, desktop_describe, or vision_action_loop, not camera_capture.
   - For image files, use image_read or vision, not desktop_describe.
   - For browser GUI action when selectors are unknown, use playwright_browser visual_click before desktop-level clicking.
+  - Match the browser mode to the claim. A clean immediate or headless run does not verify delayed headed GPU/WebGL behavior.
   - Do not claim you cannot see visual content until the relevant visual tool has failed.
 </visual-and-sensor-tools>`;
 }
@@ -701137,6 +701357,7 @@ function adaptExecutionTool(tool, options2 = {}) {
     name: tool.name,
     aliases: tool.aliases,
     description: tool.description,
+    modelFacingSummary: tool.modelFacingSummary,
     parameters: tool.parameters,
     inputSchema: tool.inputSchema,
     maxResultSizeChars: tool.maxResultSizeChars,
@@ -781438,6 +781659,30 @@ function parseTelegramSilentReflectionNotes(text3) {
   }
   return null;
 }
+function telegramInteractionDecisionResponseFormatForPacket(packet) {
+  const format3 = structuredClone(
+    TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT
+  );
+  const properties = format3.json_schema.schema.properties;
+  properties.input_id = {
+    type: "string",
+    enum: [packet.inputId]
+  };
+  properties.addressed_actor_keys = {
+    type: "array",
+    items: { type: "string", enum: packet.actorKeys },
+    maxItems: 12
+  };
+  properties.evidence_ids = {
+    type: "array",
+    items: {
+      type: "string",
+      enum: packet.evidence.map((entry) => entry.id)
+    },
+    maxItems: 16
+  };
+  return format3;
+}
 function extractPartialTelegramReplyJson(buffer2) {
   const stripped = stripTelegramHiddenThinking(buffer2).trimStart();
   if (!stripped.startsWith("{")) {
@@ -786166,8 +786411,8 @@ ${context2}` : context2;
           }
           await this.transitionTelegramIntake(
             intakeRecord,
-            "consumed",
-            "attention router retained active-runner input as context without reply authority",
+            decision2.source === "inference-unavailable" ? "failed" : "consumed",
+            decision2.source === "inference-unavailable" ? "attention router could not produce a valid input-bound decision" : "attention router retained active-runner input as context without reply authority",
             { runId: sameRunner ? currentSubAgent.runId : expectedSubAgent.runId }
           );
           return;
@@ -789246,6 +789491,8 @@ ${antecedents.join("\n")}` : "Immediate antecedents: none.",
           scenarioConfidence: decision2.scenarioConfidence,
           scenarioObjective: decision2.scenarioObjective,
           scenarioStateLoop: decision2.scenarioStateLoop,
+          diagnosticNote: decision2.diagnosticNote,
+          validationIssueCodes: decision2.validationIssueCodes,
           salienceSignals,
           self: this.telegramSelfSocialActorInput(),
           daydreamOpportunities
@@ -791646,10 +791893,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
                 id2,
                 `broker queue admission deadline expired for ${deadline.request_id}${queueSummary ? ` (${queueSummary})` : ""}; re-entering after ${(delayMs / 1e3).toFixed(1)}s, attempt ${brokerQueueRetryAttempt}`
               );
-              await this.waitForTelegramBrokerQueueRetry(
-                delayMs,
-                lifecycleSignal
-              );
+              await this.waitForTelegramBrokerQueueRetry(delayMs, lifecycleSignal);
             }
           }
           const usage = result.usage;
@@ -792032,6 +792276,15 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
       getTelegramThinkingVisible() {
         return this.telegramThinkingVisible;
       }
+      telegramMentionActorIsSelf(actor) {
+        const selfUserId = this.currentTelegramBotUserId();
+        if (selfUserId !== void 0 && actor.userId !== void 0 && actor.userId === selfUserId) {
+          return true;
+        }
+        const selfUsername = this.state.botUsername.trim().replace(/^@/, "").toLowerCase();
+        const actorUsername = actor.username?.trim().replace(/^@/, "").toLowerCase();
+        return Boolean(selfUsername && actorUsername === selfUsername);
+      }
       buildTelegramInteractionEvidencePacket(msg) {
         const sessionKey = this.sessionKeyForMessage(msg);
         const selfActorKey = telegramSocialActorKey(
@@ -792057,7 +792310,7 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
         ];
         const mentionedActors = msg.mentionedActors ?? (msg.mentionedUsernames ?? []).map((username) => ({ username }));
         mentionedActors.forEach((actor, index) => {
-          const actorKey = telegramSocialActorKey(actor);
+          const actorKey = this.telegramMentionActorIsSelf(actor) ? selfActorKey : telegramSocialActorKey(actor);
           if (actorKey === "unknown") return;
           actorKeys.add(actorKey);
           evidence.push({
@@ -792097,33 +792350,103 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
           evidence
         };
       }
-      validateTelegramInteractionDecision(decision2, packet) {
-        if (decision2.inputId !== packet.inputId) return null;
-        if (!decision2.selfRole || !decision2.replyBasis) return null;
+      validateTelegramInteractionDecisionDetailed(decision2, packet) {
+        const issues = [];
+        if (!decision2.inputId) {
+          issues.push({
+            code: "missing_input_id",
+            message: `input_id must be ${JSON.stringify(packet.inputId)}.`
+          });
+        } else if (decision2.inputId !== packet.inputId) {
+          issues.push({
+            code: "input_id_mismatch",
+            message: `input_id must be ${JSON.stringify(packet.inputId)}.`
+          });
+        }
+        if (!decision2.selfRole) {
+          issues.push({
+            code: "missing_self_role",
+            message: "self_role is required."
+          });
+        }
+        if (!decision2.replyBasis) {
+          issues.push({
+            code: "missing_reply_basis",
+            message: "reply_basis is required."
+          });
+        }
         const addressed = decision2.addressedActorKeys ?? [];
         const evidenceIds = decision2.evidenceIds ?? [];
         const allowedActors = new Set(packet.actorKeys);
         const allowedEvidence = new Set(packet.evidence.map((entry) => entry.id));
-        if (addressed.some((key) => !allowedActors.has(key))) return null;
-        if (evidenceIds.some((id2) => !allowedEvidence.has(id2))) return null;
+        const unknownActors = addressed.filter((key) => !allowedActors.has(key));
+        if (unknownActors.length > 0) {
+          issues.push({
+            code: "unknown_addressed_actor",
+            message: `addressed_actor_keys contains unknown values ${JSON.stringify(unknownActors)}. Allowed values: ${JSON.stringify(packet.actorKeys)}.`
+          });
+        }
+        const unknownEvidence = evidenceIds.filter(
+          (id2) => !allowedEvidence.has(id2)
+        );
+        if (unknownEvidence.length > 0) {
+          issues.push({
+            code: "unknown_evidence_id",
+            message: `evidence_ids contains unknown values ${JSON.stringify(unknownEvidence)}. Allowed values: ${JSON.stringify([...allowedEvidence])}.`
+          });
+        }
         if (decision2.selfRole === "addressee") {
-          if (!addressed.includes(packet.selfActorKey)) return null;
+          if (!addressed.includes(packet.selfActorKey)) {
+            issues.push({
+              code: "addressee_missing_self_actor",
+              message: `self_role=addressee requires addressed_actor_keys to include ${JSON.stringify(packet.selfActorKey)}.`
+            });
+          }
         } else if (decision2.selfRole === "observer") {
-          if (addressed.includes(packet.selfActorKey)) return null;
+          if (addressed.includes(packet.selfActorKey)) {
+            issues.push({
+              code: "observer_addresses_self",
+              message: `self_role=observer cannot address ${JSON.stringify(packet.selfActorKey)}.`
+            });
+          }
         }
         if (decision2.shouldReply) {
-          if (decision2.replyBasis === "none" || decision2.replyBasis === "uncertain" || evidenceIds.length === 0) {
-            return null;
+          if (decision2.replyBasis === "none" || decision2.replyBasis === "uncertain") {
+            issues.push({
+              code: "reply_basis_not_authorized",
+              message: "should_reply=true requires reply_basis direct_turn, ongoing_self_task, or social_intervention."
+            });
           }
-          if (decision2.replyBasis === "direct_turn" && (decision2.selfRole !== "addressee" || !addressed.includes(packet.selfActorKey))) {
-            return null;
+          if (evidenceIds.length === 0) {
+            issues.push({
+              code: "reply_missing_evidence",
+              message: "should_reply=true requires at least one evidence_id."
+            });
+          }
+          if (decision2.replyBasis === "direct_turn") {
+            if (decision2.selfRole !== "addressee") {
+              issues.push({
+                code: "direct_turn_self_not_addressee",
+                message: "reply_basis=direct_turn requires self_role=addressee."
+              });
+            }
+            if (!addressed.includes(packet.selfActorKey)) {
+              issues.push({
+                code: "direct_turn_missing_self_actor",
+                message: `reply_basis=direct_turn requires addressed_actor_keys to include ${JSON.stringify(packet.selfActorKey)}.`
+              });
+            }
           }
           if (decision2.replyBasis === "ongoing_self_task" && !packet.evidence.some(
             (entry) => entry.kind === "active_task" && evidenceIds.includes(entry.id)
           )) {
-            return null;
+            issues.push({
+              code: "ongoing_task_missing_active_task_evidence",
+              message: "reply_basis=ongoing_self_task requires the active_task evidence ID."
+            });
           }
         }
+        if (issues.length > 0) return { decision: null, issues };
         const decisionId = `tgdec-${createHash74("sha256").update(
           JSON.stringify({
             inputId: packet.inputId,
@@ -792135,7 +792458,30 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
             evidenceIds
           })
         ).digest("hex").slice(0, 20)}`;
-        return { ...decision2, decisionId };
+        return { decision: { ...decision2, decisionId }, issues: [] };
+      }
+      validateTelegramInteractionDecision(decision2, packet) {
+        return this.validateTelegramInteractionDecisionDetailed(decision2, packet).decision;
+      }
+      /**
+       * Materialize fields that are logical consequences of the model's chosen
+       * reply basis. The model still decides whether to reply and why. Once it
+       * chooses direct_turn, however, asking it to repeat "self is an addressee"
+       * in two additional fields creates three representations of one decision.
+       * A disagreement between those copies must not spend another inference.
+       */
+      normalizeTelegramInteractionDecisionImplications(decision2, packet) {
+        if (decision2.replyBasis !== "direct_turn") return decision2;
+        return {
+          ...decision2,
+          addressedActorKeys: [
+            .../* @__PURE__ */ new Set([
+              ...decision2.addressedActorKeys ?? [],
+              packet.selfActorKey
+            ])
+          ],
+          selfRole: "addressee"
+        };
       }
       bindTrustedTelegramDecision(decision2, packet) {
         const bound = {
@@ -792148,13 +792494,20 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
         };
         return this.validateTelegramInteractionDecision(bound, packet) ?? bound;
       }
-      async retryTelegramInteractionDecisionStrict(backend, userPrompt, forcedRoute, timeoutMs, diagnostics, sessionKey = "__router__", evidencePacket) {
+      async retryTelegramInteractionDecisionStrict(backend, userPrompt, forcedRoute, timeoutMs, diagnostics, sessionKey = "__router__", evidencePacket, validationIssues = []) {
         const routeInstruction = forcedRoute ? `The operator selected Telegram mode "${forcedRoute}". The route field must be "${forcedRoute}", but should_reply must still be inferred from context.` : `Infer route live from context.`;
         const retryPrompt = [
           `A prior attempt failed the typed Telegram attention-decision contract and was discarded.`,
           `Make a fresh model-derived attention decision from the complete clean context below.`,
           `Return exactly one JSON object and no prose. No <think> tags. No commentary.`,
           routeInstruction,
+          ...validationIssues.length > 0 ? [
+            `The host rejected the prior semantic contract for these exact reasons:`,
+            ...validationIssues.map(
+              (issue2) => `- ${issue2.code}: ${issue2.message}`
+            ),
+            `Correct every listed issue. Do not repeat a rejected identifier.`
+          ] : [],
           ``,
           `Required schema: ${TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA}`,
           ``,
@@ -792177,7 +792530,7 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
               maxTokens: 700,
               timeoutMs: telegramRouterTimeoutMs(timeoutMs, 8e3, 15e3),
               think: false,
-              responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT
+              responseFormat: evidencePacket ? telegramInteractionDecisionResponseFormatForPacket(evidencePacket) : TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT
             },
             diagnostics,
             "router-strict-retry",
@@ -792193,11 +792546,23 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
             defaultShouldReply: false,
             requireShouldReply: true
           });
-          const validated = parsed && evidencePacket ? this.validateTelegramInteractionDecision(parsed, evidencePacket) : parsed;
+          if (parsed && evidencePacket) parsed.inputId = evidencePacket.inputId;
+          const normalized4 = parsed && evidencePacket ? this.normalizeTelegramInteractionDecisionImplications(
+            parsed,
+            evidencePacket
+          ) : parsed;
+          const validation = normalized4 && evidencePacket ? this.validateTelegramInteractionDecisionDetailed(
+            normalized4,
+            evidencePacket
+          ) : { decision: normalized4, issues: [] };
+          const validated = validation.decision;
           if (!validated) {
             if (diagnostics) {
               const cleaned = stripTelegramHiddenThinking(retryText).trim();
-              diagnostics.strictRetryStatus = cleaned ? "unparseable" : "empty";
+              diagnostics.strictRetryStatus = parsed && validation.issues.length > 0 ? "semantic-invalid" : cleaned ? "unparseable" : "empty";
+              diagnostics.strictRetryValidationIssues = validation.issues.map(
+                (issue2) => issue2.code
+              );
             }
             return null;
           }
@@ -792750,7 +793115,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
               maxTokens: 360,
               timeoutMs: telegramRouterTimeoutMs(config.timeoutMs, 8e3, 3e4),
               think: false,
-              responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT
+              responseFormat: telegramInteractionDecisionResponseFormatForPacket(evidencePacket)
             },
             diagnostics,
             "router",
@@ -792780,7 +793145,24 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             defaultShouldReply: false,
             requireShouldReply: true
           });
-          const validated = parsed ? this.validateTelegramInteractionDecision(parsed, evidencePacket) : null;
+          if (parsed) parsed.inputId = evidencePacket.inputId;
+          const normalized4 = parsed ? this.normalizeTelegramInteractionDecisionImplications(
+            parsed,
+            evidencePacket
+          ) : null;
+          const initialValidation = normalized4 ? this.validateTelegramInteractionDecisionDetailed(
+            normalized4,
+            evidencePacket
+          ) : {
+            decision: null,
+            issues: []
+          };
+          if (diagnostics) {
+            diagnostics.validationIssues = initialValidation.issues.map(
+              (issue2) => issue2.code
+            );
+          }
+          const validated = initialValidation.decision;
           if (validated) {
             return withRouterTelemetry(
               this.applyTelegramSilentReflectionNotes(validated, reflectionNotes)
@@ -792812,7 +793194,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             config.timeoutMs ?? 3e4,
             diagnostics,
             sessionKey,
-            evidencePacket
+            evidencePacket,
+            initialValidation.issues
           );
           if (strictRetry) {
             return withRouterTelemetry(
@@ -792826,20 +793209,26 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
           ) || telegramRouterErrorLooksLikeBackendLiveness(
             diagnostics.strictRetryError ?? ""
           );
-          const fallback = this.applyTelegramSilentReflectionNotes(
-            this.buildTelegramRouterUnavailableDecision(msg, toolContext, {
-              reason: backendLivenessFailure ? "router recovery hit a backend liveness failure; no model-derived reply decision" : dualEmptyVisible ? "router returned no visible decision content in JSON or plain mode; no model-derived reply decision" : "router output failed the typed decision contract and the fresh retry; no model-derived reply decision",
-              silentDisposition: reflectionNotes.silentDisposition,
-              diagnosticNote: this.composeTelegramRouterDiagnosticNote(
-                invalidRouterPreview,
-                failureNarrative,
-                backendLivenessFailure ? "router backend failed during attention-decision recovery; no usable router decision was available" : dualEmptyVisible ? "router returned no visible decision content in JSON or plain mode; fresh typed retry did not recover it" : invalidRouterPreview ? "router produced an invalid attention decision payload; the quarantined fresh retry did not recover it" : "router produced an empty attention decision payload; the fresh typed retry did not recover it",
-                diagnostics
-              ),
-              raw: text3
-            }),
-            reflectionNotes
-          );
+          const fallback = {
+            ...this.applyTelegramSilentReflectionNotes(
+              this.buildTelegramRouterUnavailableDecision(msg, toolContext, {
+                reason: backendLivenessFailure ? "router recovery hit a backend liveness failure; no model-derived reply decision" : dualEmptyVisible ? "router returned no visible decision content in JSON or plain mode; no model-derived reply decision" : "router output failed the typed decision contract and the fresh retry; no model-derived reply decision",
+                silentDisposition: reflectionNotes.silentDisposition,
+                diagnosticNote: this.composeTelegramRouterDiagnosticNote(
+                  invalidRouterPreview,
+                  failureNarrative,
+                  backendLivenessFailure ? "router backend failed during attention-decision recovery; no usable router decision was available" : dualEmptyVisible ? "router returned no visible decision content in JSON or plain mode; fresh typed retry did not recover it" : invalidRouterPreview ? "router produced an invalid attention decision payload; the quarantined fresh retry did not recover it" : "router produced an empty attention decision payload; the fresh typed retry did not recover it",
+                  diagnostics
+                ),
+                raw: text3
+              }),
+              reflectionNotes
+            ),
+            validationIssueCodes: [
+              ...diagnostics.validationIssues ?? [],
+              ...diagnostics.strictRetryValidationIssues ?? []
+            ].filter((code8, index, all2) => all2.indexOf(code8) === index)
+          };
           return withRouterTelemetry(fallback);
         } catch (err) {
           if (err instanceof TelegramBridgeStoppedError) throw err;
@@ -792918,7 +793307,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
               `empty visible content after <think> strip during ${affected}`
             );
           }
-          if (visibleAttempts.length > 0 && diag.strictRetryStatus !== "recovered") {
+          if (visibleAttempts.length > 0 && (diag.validationIssues ?? []).length === 0 && diag.strictRetryStatus !== "recovered") {
             parts.push(`visible router text remained unparseable`);
           }
           if (skippedAttempts.length > 0) {
@@ -792969,6 +793358,10 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
           detailParts.push(
             `strict-retry: unparseable (preview="${diag.strictRetryPreview ?? ""}")`
           );
+        } else if (diag.strictRetryStatus === "semantic-invalid") {
+          detailParts.push(
+            `strict-retry: semantic-invalid (${(diag.strictRetryValidationIssues ?? []).join(", ") || "no issue codes"})`
+          );
         } else if (diag.strictRetryStatus === "threw") {
           detailParts.push(
             `strict-retry: threw (${diag.strictRetryError ?? "no detail"})`
@@ -792980,6 +793373,19 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         } else if (diag.strictRetryStatus === "recovered") {
           detailParts.push(`strict-retry: recovered`);
         }
+        if ((diag.validationIssues ?? []).length > 0) {
+          parts.push(
+            `router semantic contract rejected (${diag.validationIssues.join(", ")})`
+          );
+          detailParts.push(
+            `router-validation: ${diag.validationIssues.join(", ")}`
+          );
+        }
+        if ((diag.strictRetryValidationIssues ?? []).length > 0) {
+          detailParts.push(
+            `strict-retry-validation: ${diag.strictRetryValidationIssues.join(", ")}`
+          );
+        }
         let operatorHint;
         if (networkErrorSeen) {
           operatorHint = this.telegramRouterBackendLivenessHint(timeoutSeen);
@@ -795145,8 +795551,8 @@ Join: ${newUrl}`
             work.intakeRecords.map(
               (intake) => this.transitionTelegramIntake(
                 intake,
-                "consumed",
-                "Telegram attention router retained intake without visible reply"
+                decision2.source === "inference-unavailable" ? "failed" : "consumed",
+                decision2.source === "inference-unavailable" ? "Telegram attention router could not produce a valid input-bound decision" : "Telegram attention router retained intake without visible reply"
               )
             )
           );

package/dist/update-worker.js

@@ -290365,7 +290365,6 @@ init_process_lifecycle();
 import { dirname as dirname2, join as join2, resolve as resolve3 } from "node:path";
 import { homedir as homedir3, tmpdir } from "node:os";
 init_vision();
-var dynamicImport = new Function("mod", "return import(mod)");
 var PLAYWRIGHT_RUNTIME_DIR = join2(homedir3(), ".omnius", "playwright-runtime");
 var PLAYWRIGHT_BROWSERS_DIR = join2(PLAYWRIGHT_RUNTIME_DIR, "browsers");
 

package/npm-shrinkwrap.json

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

package/package.json

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