deploy(S4): Blender headless pipeline + WebAR client + backend fixes (part 2)

modules/initiative.py

@@ -73,6 +73,12 @@ _lock = threading.RLock()
 # is still far more attentive than a person checking in on you.
 TICK_SECONDS = 900
 
+# How often the runtime-repair queue is distilled into standing rules. Four
+# ticks is once an hour: often enough that a lesson learned this morning is in
+# force by the afternoon, rare enough that it costs a handful of model calls a
+# day. See omega_executor.apply_pending_repairs.
+REPAIR_EVERY_TICKS = 4
+
 # Never act twice on the same judgement inside this window, even if the
 # situation persists. Without it a condition that stays true — a disk staying
 # full — would be acted on every single tick.
@@ -470,6 +476,46 @@ def judge(situation: str) -> Judgement:
     except Exception:
         pass
 
+    # WHO THIS IS HAPPENING TO.
+    #
+    # The context used to be `SITUATION: …` and nothing else — CPU, battery,
+    # window titles. So the one part of JARVIS that acts WITHOUT being asked was
+    # also the only part that knew nothing whatsoever about the operator: not
+    # what they had told him, not what they were working on, not what they had
+    # already asked him to leave alone. Deciding to act on someone unprompted
+    # while knowing nothing about them is the wrong way round — this is the
+    # place that needs the operator's context most, not least.
+    operator = ""
+    try:
+        from modules.memory import get_insights, get_unfinished_tasks
+        insights = get_insights() or []
+        tasks = get_unfinished_tasks() or []
+        bits = []
+        # The SHARED store first — this is where anything said on the phone
+        # lands, and the part of JARVIS that acts unasked is the last place that
+        # should be working from a different set of facts than the one the
+        # operator has been talking to all day.
+        try:
+            from modules.operator_memory import recall_text
+            shared = recall_text(limit=20)
+            if shared:
+                bits.append(shared)
+        except Exception:
+            pass
+        if insights:
+            bits.append("WHAT YOU KNOW ABOUT THEM: "
+                        + " | ".join(str(i) for i in list(insights)[-12:]))
+        if tasks:
+            bits.append("THINGS THEY LEFT UNFINISHED: "
+                        + ", ".join(str(t) for t in list(tasks)[:8]))
+        operator = "\n".join(bits)[:2000]
+    except Exception:
+        operator = ""
+
+    context_block = f"SITUATION: {situation}"
+    if operator:
+        context_block = f"{context_block}\n\n{operator}"
+
     try:
         from core.brain_router import ask_router
         # NOT "what do you make of this?" — that is an invitation to comment,
@@ -478,7 +524,7 @@ def judge(situation: str) -> Judgement:
         rep = ask_router(
             user_text="Is this worth interrupting them for? Return the JSON.",
             system_prompt=system,
-            context_block=f"SITUATION: {situation}",
+            context_block=context_block,
             provider_order=["gemini", "local"],
         )
         raw = (getattr(rep, "text", "") or "").strip()
@@ -539,15 +585,25 @@ def tick(speak: Optional[Callable[[str], None]] = None,
 
     _mark_acted(verdict.topic)
 
-    if verdict.say:
-        # Through alert_manager so repeat suppression and snoozes apply to
-        # unprompted speech exactly as they do to alerts.
-        try:
-            from modules.alert_manager import should_speak
-            if should_speak(verdict.topic, verdict.urgency):
-                say(verdict.say)
-        except Exception:
-            say(verdict.say)
+    # ACT FIRST, THEN SAY WHAT HAPPENED.
+    #
+    # This block used to speak `verdict.say` BEFORE running `verdict.action`,
+    # and `verdict.say` is written by the model in the same breath as the plan —
+    # so it is always phrased as an accomplishment: "I've saved your unfinished
+    # work, sir." Then the action ran, and:
+    #
+    #   · `if res.ok:` had no else, so a failed action said nothing at all;
+    #   · `except Exception: pass` swallowed an executor that never even ran.
+    #
+    # Either way the operator had already been told it was done. Reported
+    # exactly that way: "he says I saved your unfinished work but does not
+    # actually do it, just says he did."
+    #
+    # Unprompted action is the one place this matters most. Nobody is watching
+    # when it happens, so the spoken line IS the whole record — if it lies,
+    # there is nothing else to catch it.
+    acted_ok: Optional[bool] = None
+    failure_note = ""
 
     if allow_actions and verdict.action:
         try:
@@ -558,12 +614,43 @@ def tick(speak: Optional[Callable[[str], None]] = None,
                 # It is announced first and deliberated, never silent.
                 say(f"Acting on my own initiative: {verdict.action}.")
             res = execute(verdict.action, speak=say)
-            # Written down whether or not anyone heard it happen. This is what
-            # becomes "I did this for you, sir" when they come back.
-            if res.ok:
+            acted_ok = bool(getattr(res, "ok", False))
+            if acted_ok:
+                # Written down whether or not anyone heard it happen. This is
+                # what becomes "I did this for you, sir" when they come back.
                 record_done(verdict.action, res.spoken, reversible=not risky)
+            else:
+                failure_note = (getattr(res, "spoken", "") or "").strip()
+        except Exception as exc:
+            acted_ok = False
+            failure_note = f"{type(exc).__name__}: {exc}"[:160]
+            import logging as _logging
+            _logging.getLogger(__name__).warning(
+                "initiative action failed: %s", failure_note)
+
+    if verdict.say:
+        line = verdict.say
+        if acted_ok is False:
+            # Replace the claim outright rather than appending a caveat to it —
+            # "I saved your work, but it failed" still opens by saying it saved.
+            line = "I tried to handle something for you and it did not work"
+            if verdict.action:
+                line += f": {verdict.action.strip().rstrip('.')}"
+            line += "."
+            if failure_note:
+                line += f" {failure_note}"
+        # Through alert_manager so repeat suppression and snoozes apply to
+        # unprompted speech exactly as they do to alerts.
+        try:
+            from modules.alert_manager import should_speak
+            if should_speak(verdict.topic, verdict.urgency):
+                say(line)
         except Exception:
-            pass
+            say(line)
+    elif acted_ok is False:
+        # No line was planned, but something was attempted and failed. Silence
+        # here is how a broken autonomous action becomes invisible forever.
+        say("I tried to take care of something and it did not work.")
 
     return verdict
 
@@ -586,11 +673,32 @@ def start(speak: Optional[Callable[[str], None]] = None) -> bool:
             pass
 
     def _run():
+        # THE LASTING FIX, ON ITS OWN SCHEDULE.
+        #
+        # omega_executor repairs a broken step mid-task so the operator is not
+        # blocked — that half worked. The other half, "then later fix it
+        # properly by yourself, and tell me once it is done", was a queue with
+        # no consumer: `pending_repairs()` was read by exactly one route that
+        # displays it. Every lesson was re-learned from scratch on every run.
+        #
+        # Here is the consumer. It runs far less often than the watch tick,
+        # because distilling a rule costs a model call and nothing is urgent
+        # about it, and it speaks only after the fact — which is what was asked
+        # for: do not interrupt me doing it, tell me when it is done.
+        every = max(1, int(REPAIR_EVERY_TICKS))
+        ticks = 0
         while _running:
             try:
                 tick(_say)
             except Exception:
                 pass
+            ticks += 1
+            if ticks % every == 0:
+                try:
+                    from modules.omega_executor import apply_pending_repairs
+                    apply_pending_repairs(speak=_say)
+                except Exception:
+                    pass
             time.sleep(TICK_SECONDS)
 
     _running = True

modules/input_control.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import time
 from dataclasses import dataclass
+from typing import Optional
 
 import keyboard  # type: ignore
 
@@ -28,16 +29,261 @@ class InputResult:
 
 
 def type_text(text: str) -> InputResult:
+    """Type into WHATEVER has focus. Prefer [type_into] — see the note there."""
     t = (text or "")
     if not t.strip():
         return InputResult(False, "No text to type.")
     try:
         keyboard.write(t)
-        return InputResult(True, "Typed.")
+        # Deliberately does NOT claim the text landed anywhere in particular:
+        # this function cannot know. type_into can, and says so.
+        return InputResult(True, f"Sent {len(t)} characters to the focused window.")
     except Exception as e:
         return InputResult(False, f"Type failed: {e}")
 
 
+# ── Typing INTO something, with proof ────────────────────────────────────────
+#
+# "Open the terminal and write claude" opened the terminal and typed nothing,
+# and JARVIS reported: "Done. 3 steps: Open the Windows terminal; waited 1s;
+# Write claude to the terminal." Every layer said yes:
+#
+#   · keyboard.write() cannot fail loudly — it posts keystrokes to whatever has
+#     focus at that instant. If the terminal has not finished opening, they go
+#     to the desktop and vanish.
+#   · type_text returned InputResult(True, "Typed.") unconditionally.
+#   · omega_executor._run_shell scores a step by `returncode == 0`, and a
+#     PowerShell SendKeys exits 0 whether or not anything received the keys.
+#
+# Exit code is evidence that a command RAN. For UI automation it is not evidence
+# that the intended thing HAPPENED, and the two were being treated as the same.
+#
+# So this focuses the target window, CHECKS that it really is in the foreground,
+# and only then types. If focus cannot be won — Windows refuses
+# SetForegroundWindow to background processes in several situations — it returns
+# False with the window that actually had focus, which is a fact the operator
+# can act on.
+
+def _win32():
+    import ctypes
+    from ctypes import wintypes
+    return ctypes, wintypes, ctypes.windll.user32
+
+
+def foreground_title() -> str:
+    """Title of the window that currently has focus ('' if unavailable)."""
+    try:
+        ctypes, wintypes, u32 = _win32()
+        hwnd = u32.GetForegroundWindow()
+        if not hwnd:
+            return ""
+        n = u32.GetWindowTextLengthW(hwnd)
+        buf = ctypes.create_unicode_buffer(n + 1)
+        u32.GetWindowTextW(hwnd, buf, n + 1)
+        return buf.value or ""
+    except Exception:
+        return ""
+
+
+def focus_window(title_substr: str, timeout: float = 6.0) -> InputResult:
+    """Bring a window matching `title_substr` to the front, and VERIFY it."""
+    want = (title_substr or "").strip().lower()
+    if not want:
+        return InputResult(False, "No window named.")
+    try:
+        ctypes, wintypes, u32 = _win32()
+    except Exception as e:
+        return InputResult(False, f"Win32 unavailable: {e}")
+
+    SW_RESTORE = 9
+    deadline = time.time() + max(0.5, timeout)
+
+    while time.time() < deadline:
+        found: list[int] = []
+
+        @ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
+        def _enum(hwnd, _lparam):
+            if not u32.IsWindowVisible(hwnd):
+                return True
+            n = u32.GetWindowTextLengthW(hwnd)
+            if n <= 0:
+                return True
+            buf = ctypes.create_unicode_buffer(n + 1)
+            u32.GetWindowTextW(hwnd, buf, n + 1)
+            if want in (buf.value or "").lower():
+                found.append(hwnd)
+                return False
+            return True
+
+        try:
+            u32.EnumWindows(_enum, 0)
+        except Exception:
+            pass
+
+        if found:
+            hwnd = found[0]
+            try:
+                u32.ShowWindow(hwnd, SW_RESTORE)
+                # SetForegroundWindow ALONE IS NOT ENOUGH.
+                #
+                # Windows refuses it from a process that does not already own
+                # the foreground — it flashes the taskbar button instead and
+                # returns as if nothing were wrong. That is the single biggest
+                # reason "open X and type Y" typed into the wrong place: the
+                # focus call quietly did nothing and the keystrokes went to
+                # whatever was still in front.
+                #
+                # Attaching our input queue to the foreground window's thread
+                # makes us a legitimate foreground-setter for the duration.
+                # This is the documented way round the restriction and is what
+                # every automation tool does.
+                cur = u32.GetForegroundWindow()
+                our_tid = ctypes.windll.kernel32.GetCurrentThreadId()
+                tgt_tid = u32.GetWindowThreadProcessId(hwnd, None)
+                cur_tid = u32.GetWindowThreadProcessId(cur, None) if cur else 0
+                attached = []
+                for tid in {tgt_tid, cur_tid}:
+                    if tid and tid != our_tid and u32.AttachThreadInput(our_tid, tid, True):
+                        attached.append(tid)
+                try:
+                    u32.BringWindowToTop(hwnd)
+                    u32.SetForegroundWindow(hwnd)
+                    u32.SetActiveWindow(hwnd)
+                    u32.SetFocus(hwnd)
+                finally:
+                    for tid in attached:
+                        u32.AttachThreadInput(our_tid, tid, False)
+            except Exception:
+                pass
+            # VERIFY. SetForegroundWindow returns non-zero on refusal in some
+            # cases and Windows may simply flash the taskbar instead, so the
+            # only trustworthy check is asking who is in front now.
+            time.sleep(0.25)
+            if u32.GetForegroundWindow() == hwnd:
+                return InputResult(True, f"Focused '{title_substr}'.")
+        time.sleep(0.3)
+
+    actual = foreground_title()
+    return InputResult(
+        False,
+        f"Could not bring '{title_substr}' to the front"
+        + (f"; '{actual}' has focus instead." if actual else "."),
+    )
+
+
+def read_focused_text() -> Optional[str]:
+    """Read the text of the focused window's edit control, or None.
+
+    Generic Win32: any standard EDIT / RichEdit / Scintilla child answers
+    WM_GETTEXT. Terminals, Electron apps and custom-drawn UIs do not, and that
+    is why this returns None rather than "" — "could not read" and "read, and it
+    was empty" are completely different answers and must not be confused.
+    """
+    try:
+        import ctypes
+        ctypes, wintypes, u32 = _win32()
+        hwnd = u32.GetForegroundWindow()
+        if not hwnd:
+            return None
+        found: list[str] = []
+
+        @ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
+        def _child(h, _l):
+            cls = ctypes.create_unicode_buffer(256)
+            u32.GetClassNameW(h, cls, 256)
+            name = (cls.value or "").lower()
+            if "edit" in name or "scintilla" in name:
+                n = u32.SendMessageW(h, 0x000E, 0, 0)          # WM_GETTEXTLENGTH
+                b = ctypes.create_unicode_buffer(n + 2)
+                u32.SendMessageW(h, 0x000D, n + 2, b)          # WM_GETTEXT
+                found.append(b.value or "")
+                return False
+            return True
+
+        u32.EnumChildWindows(hwnd, _child, 0)
+        return found[0] if found else None
+    except Exception:
+        return None
+
+
+def type_into(text: str, window: str = "", timeout: float = 6.0,
+              delay: float = 0.012) -> InputResult:
+    """Focus `window`, prove it has focus, type `text`, then CHECK IT LANDED.
+
+    Three failures this has to survive, all found by testing it rather than by
+    reading it:
+
+    1. WRONG WINDOW. Without an explicit focus step the keys go wherever focus
+       happens to be, which right after launching an app is a race against that
+       app's startup.
+
+    2. DROPPED CHARACTERS. `keyboard.write(t)` with no delay sends keystrokes
+       faster than the target can consume them. Measured on Notepad immediately
+       after a focus change: of `omega_verify_1786893995`, exactly ONE character
+       arrived — and the step still reported "Done". A per-character delay is
+       not politeness, it is the difference between typing and appearing to.
+
+    3. CLAIMING WITHOUT LOOKING. Focus being correct before and after does not
+       mean the text is in the control. Where the control can be read, it is
+       read back and compared; where it cannot, the result says so explicitly
+       instead of asserting success it has not checked.
+    """
+    t = text or ""
+    if not t.strip():
+        return InputResult(False, "No text to type.")
+
+    if window.strip():
+        got = focus_window(window, timeout=timeout)
+        if not got.ok:
+            return InputResult(False, f"Did not type: {got.message}")
+
+    before_text = read_focused_text()
+    before = foreground_title()
+    try:
+        # delay= is the fix for (2). keyboard.write accepts it on every version
+        # that has write(); the fallback keeps older builds working.
+        try:
+            keyboard.write(t, delay=delay)
+        except TypeError:
+            for ch in t:
+                keyboard.write(ch)
+                time.sleep(delay)
+    except Exception as e:
+        return InputResult(False, f"Type failed: {e}")
+
+    after = foreground_title()
+    if before and after and before != after:
+        return InputResult(
+            False,
+            f"Focus moved from '{before}' to '{after}' while typing — "
+            f"the text may be incomplete.",
+        )
+
+    # ── did it land? ────────────────────────────────────────────────────────
+    time.sleep(0.15)                      # let the control settle
+    after_text = read_focused_text()
+    if after_text is None:
+        # Unreadable control (a terminal, a browser, a custom UI). Say so.
+        return InputResult(
+            True,
+            f"Typed {len(t)} characters into '{after or window}' "
+            f"(this window's contents cannot be read back, so delivery is "
+            f"not confirmed).",
+        )
+
+    if t in after_text:
+        return InputResult(
+            True, f"Typed and verified {len(t)} characters in '{after or window}'.")
+
+    # Landed partially, or not at all. Report exactly how much.
+    grew = len(after_text) - len(before_text or "")
+    return InputResult(
+        False,
+        f"Only {max(0, grew)} of {len(t)} characters reached "
+        f"'{after or window}' — the text was not fully entered.",
+    )
+
+
 def hotkey(combo: str) -> InputResult:
     c = (combo or "").strip()
     if not c:

modules/intent.py

@@ -54,7 +54,7 @@ class Intent:
 # Deliberately generous. These are not "the supported phrasings" — they are the
 # ones worth answering without a round trip.
 
-_NAME = r"(?:jarvis|jarv|friday|fri)"
+_NAME = r"(?:jarvis|jarvid|jarv|jervis|jarvas|jarwis|javis|travis|j|friday|fri|fryday|freeday|frydey)"
 
 # Any greeting-ish token, or none at all, in front of the name. This is what
 # makes "yo jarvis" work without anybody having listed "yo".

modules/omega_executor.py

@@ -91,6 +91,22 @@ _DESTRUCTIVE_PATTERNS = (
     r"\bclear-content\b", r"\brm\s+-[a-z]*[rf]", r"\brm\s+",
     r"\bcipher\s+/w\b", r"\bbcdedit\b", r"\breg\s+delete\b",
     r"\bremove-partition\b", r"\bclear-disk\b",
+
+    # PUBLISHING IS IRREVERSIBLE TOO, and it is newly reachable.
+    #
+    # The planner now knows how to deploy the Space, push to git and sync the
+    # WebAR bundle into the APK and cloud copies. Those are not "deletions", so
+    # none of the patterns above matched them — yet a deploy puts code on the
+    # public internet under the operator's name, and a push cannot be recalled
+    # once anyone has fetched it. Something that leaves this machine and cannot
+    # be pulled back deserves the same pause as something that wipes a disk.
+    #
+    # This does not block them. It routes them through the same deliberation and
+    # cancel window as a shutdown, so an unattended run says what it is about to
+    # publish before it publishes it.
+    r"\bdeploy_hf_space\b", r"\bupload_folder\b", r"\bhuggingface_hub\b",
+    r"\bgit\s+push\b", r"\bgit\s+commit\b",
+    r"\bsync_webar_bundle\b",
 )
 
 
@@ -201,11 +217,103 @@ Step kinds:
   {"kind":"say","text":"..."}
       Speak progress mid-chain.
 
+ANY step may also carry:
+
+  "verify": {"kind":"shell","cmd":"<check>"}      (or {"kind":"python","code":"..."})
+      A check that must SUCCEED, or the step is reported as failed.
+
+      REQUIRED on the step that produces the thing being asked for. If the
+      request results in a file, a setting, an installed program, a download or
+      a message sent, the step that does it MUST carry a verify. A run that
+      claims success without one has proved nothing — and this was not
+      hypothetical: "write a line to <path>" was planned as a single shell step
+      with no check, the command exited 0, no file was created, and it was
+      reported as "Done."
+
+      Use it whenever the step's real effect happens OUTSIDE the process it
+      runs — a keystroke, a click, a window, a file, a setting, a download.
+      An exit code proves the command RAN; it does not prove the thing HAPPENED.
+      A PowerShell SendKeys exits 0 whether or not any window received the keys,
+      which is exactly how "open the terminal and write claude" once opened the
+      terminal, typed nothing, and was reported as three completed steps.
+
+      Verify the RESULT, not the command:
+          wrote a file      -> Test-Path, and check its length
+          opened an app     -> Get-Process, or the window title
+          downloaded a file -> the file exists and is not zero bytes
+          changed a setting -> read the setting back
+
+THE WHOLE SYSTEM IS REACHABLE — not just this PC.
+
+  A `python` step can do anything this machine can do, and this machine can
+  change every surface OMEGA runs on. What was missing was never the power; it
+  was knowing WHERE things live, so requests about the phone, the cloud or the
+  AR client were treated as impossible when they were merely unlisted.
+
+  Paths are relative to the repo root (the working dir given below).
+
+  BACKEND (this PC and the cloud run the SAME code)
+      backend/ , modules/ , core/ , config.py
+      Restart to apply:  python -m backend.main   (health: GET :7474/health)
+
+  HF SPACE — Jarvis2345/jarvis-cloud
+      Editing backend/ is NOT enough; the Space serves its own copy.
+      Deploy:   python scripts/deploy_hf_space.py            (--dry-run first)
+      Needs HF_TOKEN. Verify:  GET https://jarvis2345-jarvis-cloud.hf.space/health
+      This publishes to the internet. Treat it as irreversible: say so first.
+
+  WEBAR — THREE physical copies of one bundle, and nothing keeps them in sync
+      source of truth   phone/eightwall_ar/dist
+      cloud copy        cloud_deployment/webar        (served by the Space)
+      apk copy          phone/jarvis-mobile-guardian/app/src/main/assets/webar
+      NEVER hand-copy — that is what caused the drift, twice.
+      Sync:    python scripts/sync_webar_bundle.py     (--check proves they agree)
+      A WebAR change that skips this reaches nobody.
+
+  ANDROID APP (Guardian)
+      phone/jarvis-mobile-guardian/
+      Build:   gradlew.bat :app:assembleRelease
+      Needs KEYSTORE_PATH / STORE_PASSWORD / KEY_PASSWORD / KEY_ALIAS or the APK
+      ships UNSIGNED and silently uninstallable. Install: adb install -r <apk>.
+
+  DESKTOP APP (exe)  src/ , dist/
+  PLAN / TIER GATING  scripts/tier_partition.py
+
+  When a request touches one of these, do the edit AND the step that makes it
+  real — a source change with no sync, deploy, build or restart has changed
+  nothing the operator can see, and reporting it as done is the same lie as any
+  other unverified step. Verify against the LIVE surface: /health, --check, the
+  installed versionName.
+
+SAVING is a FLOW, not a keystroke.
+  Ctrl+S on an unsaved document opens a Save-As dialog, which is a SEPARATE
+  WINDOW with its own filename field and its own confirm button. Sending Ctrl+S
+  and stopping there leaves that dialog open and nothing saved, while every
+  command involved exits 0.
+
+  Prefer writing the file directly when you can — a `python` step that writes
+  the content to a path is one step, needs no window, and can be verified with
+  Test-Path. Drive the GUI only when the content exists solely inside the app.
+
+  When you must use the dialog, treat each part as its own step:
+      Ctrl+S  ->  wait  ->  type_into the dialog (window "Save As")
+              ->  Enter ->  verify with Test-Path on the expected path
+  and ALWAYS end with a `verify` that the file now exists and is non-empty.
+  "It said Done" is not the same as "the file is on disk".
+
+TYPING AND FOCUS — do not use SendKeys.
+  Use {"kind":"tool","name":"type_into","args":{"text":"...","window":"..."}}.
+  It takes focus deliberately, PROVES the window is in front before sending a
+  key, and fails loudly when it cannot. Always pass `window` after launching
+  something: keystrokes sent while an app is still starting go to the desktop.
+
 Rules:
 - Decompose chains fully and in order. "download X, install it, run it 10
   minutes, close everything, shut down" is at least 5 steps, not 1.
 - Irreversible steps (shutdown, restart, format, mass delete) go LAST.
-- Never invent a tool name that is not in the catalog.
+- Never invent a tool name that is not in the catalog — but you are NOT limited
+  to the catalog: `python` lets you write whatever the request actually needs,
+  and that is the intended path for anything unanticipated.
 - Never ask the user a question; choose the sensible interpretation and act.
 - Prefer one capable step over many timid ones, but never merge a wait.
 """
@@ -254,7 +362,12 @@ def _extract_json(raw: str) -> Optional[dict]:
 
 def plan_request(request: str, context: str = "") -> dict:
     """Turn plain speech into a step plan. Never raises."""
-    system = _PLANNER_RULES + "\n\nCATALOG:\n" + _catalog_text()
+    # Standing rules distilled from things that went wrong before on THIS
+    # machine. Without this the lasting-fix queue is just a diary: the same
+    # command is planned, fails, is repaired at runtime, and is planned exactly
+    # the same way again the next time it is asked for.
+    system = (_PLANNER_RULES + "\n\nCATALOG:\n" + _catalog_text()
+              + _learned_fixes_text())
     ctx = [f"Machine: Windows. Working dir: {os.getcwd()}"]
     if context:
         ctx.append(context)
@@ -374,7 +487,25 @@ def _run_tool(name: str, args: dict) -> tuple[bool, str, str]:
                 if "e" in box:
                     return False, "", str(box["e"])
                 res = box.get("v")
-        return True, ("" if res is None else str(res))[:4000], ""
+
+        text = ("" if res is None else str(res))[:4000]
+
+        # A TOOL THAT SAYS IT FAILED, FAILED.
+        #
+        # This returned `True` for any string a tool produced, so a tool whose
+        # own answer was "Failed: Could not bring 'Notepad' to the front" was
+        # recorded as a completed step and summarised as "Done". The tool's
+        # verdict was computed and then discarded — the same shape as scoring a
+        # shell step by its exit code, one layer up.
+        #
+        # Only the START of the answer is examined, deliberately: a web search
+        # or a log excerpt may legitimately contain the word "failed" in its
+        # body, and failing the step for that would be its own kind of wrong.
+        head = text.lstrip()[:80].lower()
+        if head.startswith(("failed", "error:", "error ", "could not",
+                            "unable to", "cannot ", "no such tool")):
+            return False, "", text
+        return True, text, ""
     except Exception as e:
         return False, "", str(e)
 
@@ -406,7 +537,17 @@ def execute(request: str,
     prev_output = ""
     ok_all = True
 
-    for i, step in enumerate(steps, 1):
+    # Index-based rather than `for … in enumerate(steps)` so the REMAINING work
+    # can be replaced mid-run. See the re-plan block at the bottom of the loop:
+    # a long chain used to die at its first unrecoverable step, which is exactly
+    # where a person would instead try a different route.
+    replans = 0
+    idx = 0
+
+    while idx < len(steps):
+        step = steps[idx]
+        idx += 1
+        i = idx                      # 1-based step number, as before
         kind = str(step.get("kind", "")).lower()
         why = str(step.get("why") or step.get("text") or kind)[:180]
 
@@ -528,16 +669,96 @@ def execute(request: str,
                     break
                 step = fixed   # each attempt learns from the last error
 
+        # ── DID IT ACTUALLY HAPPEN? ──────────────────────────────────────────
+        #
+        # `good` so far means the command RAN. For anything whose effect is
+        # outside the process — a keystroke, a click, a window, a file, a
+        # setting — that is not the same as the effect having happened, and the
+        # two were being treated as identical:
+        #
+        #     return proc.returncode == 0, out, err        # _run_shell
+        #
+        # A PowerShell SendKeys exits 0 whether or not any window received the
+        # keys. That is why "open the terminal and write claude" opened the
+        # terminal, typed nothing, and was reported as "Done. 3 steps".
+        #
+        # So a step may carry `verify`: a shell or python snippet that must
+        # SUCCEED for the step to count. This deliberately does not restrict
+        # what a step is allowed to do — shell, python and code written on the
+        # spot all still work, and can be anything. It restricts what may be
+        # CLAIMED about them. Steps with no `verify` behave exactly as before.
+        verify = step.get("verify") if isinstance(step, dict) else None
+        if good and verify:
+            vkind = str((verify or {}).get("kind") or "shell").lower()
+            if vkind == "python":
+                vgood, vout, verr = _run_python(str(verify.get("code") or ""), out)
+            else:
+                vgood, vout, verr = _run_shell(str(verify.get("cmd") or ""))
+            if not vgood:
+                good = False
+                err = (err + "\n" if err else "") + (
+                    f"verification failed: {verr or vout or 'check did not pass'}")
+                why = f"{why} (unverified)"
+                _log(f"step {i} ran but FAILED VERIFICATION: {verr or vout}")
+
         results.append(StepResult(i, kind, why, good, out, err))
         if out:
             prev_output = out
         if not good:
-            ok_all = False
             _log(f"step {i} failed after repair attempts: {err[:200]}")
-            # A broken link means the rest of the chain is operating on false
-            # premises, so stop rather than plough on.
+
+            # TRY ANOTHER WAY BEFORE GIVING UP.
+            #
+            # This used to `break` — the rest of a long chain was abandoned the
+            # moment one link broke. `_repair_step` had already tried to fix
+            # THAT COMMAND twice, so by here the approach itself is what is
+            # wrong, and rewriting the same command a third time will not help.
+            #
+            # What is missing is what a person does next: keep everything that
+            # already worked, and find a different route for what is left.
+            # "Save it" is the case that exposed this — Ctrl+S, a Save-As
+            # dialog, a filename field and a confirm button is a flow with
+            # several shapes depending on the app, and the first shape being
+            # wrong should not end the task.
+            #
+            # Bounded to MAX_REPLANS so a plan that cannot work fails in seconds
+            # rather than looping, and it is told exactly what already succeeded
+            # so it does not redo it.
+            if replans < MAX_REPLANS:
+                new_steps = _replan_remainder(
+                    request, results, step, err, steps[idx:])
+                if new_steps:
+                    replans += 1
+                    steps = steps[:idx] + new_steps
+                    _log(f"re-planned {len(new_steps)} step(s) after step {i} failed")
+                    say("That didn't work. Trying another way.")
+                    continue
+
+            ok_all = False
             break
 
+    # ── FINAL OUTCOME GATE ──────────────────────────────────────────────────
+    #
+    # `verify` on a step is optional, and the planner routinely omits it. Caught
+    # exactly that way: "write a line to <path>" produced one shell step that
+    # failed, was repaired, exited 0, created nothing, and was reported as
+    # "Done." — because no step carried a check and exit codes were all the
+    # engine had to go on.
+    #
+    # So the REQUEST itself is checked, not just the steps. If the operator
+    # named a concrete file and that file is not there afterwards, the run did
+    # not do what was asked, whatever the exit codes said. Deterministic, no
+    # model call, and it cannot be forgotten by a planner.
+    if ok_all:
+        missing = _unmet_artifacts(request)
+        if missing:
+            ok_all = False
+            _log(f"outcome gate: promised artifacts missing: {missing}")
+            results.append(StepResult(
+                len(results) + 1, "verify",
+                "the file the request asked for was not created", False,
+                error="missing after the run: " + ", ".join(missing)))
+
     if ok_all:
         spoken = _summarise_success(request, results)
     else:
@@ -550,6 +771,48 @@ def execute(request: str,
 
 # ── Self-repair ─────────────────────────────────────────────────────────────
 MAX_REPAIRS = 2          # two corrected attempts, then admit it is stuck
+MAX_REPLANS = 2          # …then two attempts at a DIFFERENT route for the rest
+
+
+def _replan_remainder(request: str,
+                      done: list["StepResult"],
+                      failed_step: dict,
+                      error: str,
+                      remaining: list[dict]) -> Optional[list[dict]]:
+    """Find another way to finish, keeping everything that already worked.
+
+    Distinct from `_repair_step`, which rewrites ONE command that errored. By
+    the time this runs that has already been tried twice, so the command is not
+    the problem — the approach is. This asks for a new plan for the unfinished
+    part only, and is told what has already been done so it does not repeat it.
+    """
+    try:
+        from core.brain_router import ask_router
+        did = "\n".join(f"- DONE: {r.summary}" for r in done if r.ok) or "- (nothing yet)"
+        left = json.dumps(remaining)[:1200] if remaining else "(nothing)"
+        ctx = (f"ORIGINAL REQUEST: {request}\n"
+               f"ALREADY COMPLETED — do NOT redo these:\n{did}\n"
+               f"THE STEP THAT FAILED TWICE: {json.dumps(failed_step)[:800]}\n"
+               f"ERROR: {error[:800]}\n"
+               f"WHAT WAS STILL PLANNED: {left}\n"
+               f"Machine: Windows. Working dir: {os.getcwd()}")
+        rep = ask_router(
+            user_text=("Finish the request a DIFFERENT way. Return the same "
+                       "JSON plan format, containing ONLY the remaining steps."),
+            system_prompt=_PLANNER_RULES + "\n\nCATALOG:\n" + _catalog_text()
+                          + _learned_fixes_text(),
+            context_block=ctx,
+            provider_order=["gemini", "local"],
+        )
+        plan = _extract_json(getattr(rep, "text", "") or "")
+        if not isinstance(plan, dict):
+            return None
+        steps = [s for s in (plan.get("steps") or [])
+                 if isinstance(s, dict) and s.get("kind")]
+        return steps[:MAX_STEPS] or None
+    except Exception as e:
+        _log(f"re-plan unavailable: {e}")
+        return None
 _REPAIR_LOG = os.path.join(
     os.environ.get("JARVIS_APP_DATA_DIR") or os.path.join(
         os.path.dirname(os.path.dirname(os.path.abspath(__file__))), ".friday_data"),
@@ -653,6 +916,172 @@ def pending_repairs() -> list[dict]:
         return []
 
 
+# ── The lasting fix ─────────────────────────────────────────────────────────
+#
+# _remember_repair's docstring promised this: "a command that had to be
+# corrected at runtime will need correcting again next time unless something
+# changes — so the evidence is kept". The evidence was kept. Nothing ever read
+# it. `pending_repairs()` had exactly one caller in the whole codebase —
+# backend/routes/engine_routes.py, which LISTS the queue for a UI — so every
+# lesson learned mid-task was learned again from scratch on the next run, for
+# ever.
+#
+# That is the half of the design the operator described as "then later fix
+# properly by own without telling me, then after fix tell me", and it did not
+# exist.
+#
+# What "properly" means here is deliberate. It does NOT mean editing source
+# unsupervised — an autonomous process rewriting its own program while nobody
+# is watching is a much larger risk than the bug it is fixing. It means the
+# same mistake stops being made: each runtime correction becomes a standing
+# rule that goes into the planner's prompt, so the broken form is never planned
+# again on this machine.
+
+_LEARNED_FIXES = os.path.join(
+    os.path.dirname(_REPAIR_LOG), "learned_fixes.json")
+
+
+def _rule_key(rule: str) -> str:
+    """Normalise a rule so trivially different wordings collapse together."""
+    return re.sub(r"[^a-z0-9 ]+", "", (rule or "").lower()).strip()[:120]
+
+
+def learned_fixes() -> list[dict]:
+    """Standing corrections distilled from past runtime repairs."""
+    try:
+        with open(_LEARNED_FIXES, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+        return data if isinstance(data, list) else []
+    except Exception:
+        return []
+
+
+def _learned_fixes_text() -> str:
+    """The standing rules, as prompt text. Empty when there are none."""
+    rules = learned_fixes()
+    if not rules:
+        return ""
+    lines = [f"- {r.get('rule')}" for r in rules[-25:] if r.get("rule")]
+    if not lines:
+        return ""
+    return ("\nLEARNED ON THIS MACHINE — these went wrong before and were "
+            "corrected at runtime. Do not repeat them:\n" + "\n".join(lines))
+
+
+def apply_pending_repairs(speak: Optional[Callable[[str], None]] = None,
+                          max_items: int = 12) -> list[str]:
+    """Turn runtime corrections into standing rules. Returns what was learned.
+
+    Runs unattended. Speaks only AFTERWARDS, and only if something was actually
+    learned — the operator asked not to be interrupted during the fixing, but to
+    be told once it was done.
+    """
+    queue = pending_repairs()
+    if not queue:
+        return []
+
+    learned: list[dict] = list(learned_fixes())
+    known = {r.get("signature") for r in learned}
+    # Also dedupe on the RULE ITSELF. The signature is the exact broken command,
+    # so two runs that fail the same way with a different filename produce two
+    # different signatures and one identical lesson — observed immediately:
+    # "Use Set-Content instead of misspelled variants" was learned twice. The
+    # prompt these go into is finite; the same sentence twice costs room and
+    # teaches nothing extra.
+    known_rules = {_rule_key(r.get("rule", "")) for r in learned}
+    new_rules: list[str] = []
+
+    for item in queue[-max_items:]:
+        broken = item.get("broken") or {}
+        fixed = item.get("fixed") or {}
+        sig = f"{broken.get('cmd') or broken.get('code') or broken.get('name')}"[:300]
+        if not sig or sig in known:
+            continue
+        try:
+            from core.brain_router import ask_router
+            rep = ask_router(
+                user_text=("Write ONE short standing rule, in a single "
+                           "sentence, that would stop this from going wrong "
+                           "again. State the correct form. No preamble."),
+                system_prompt=("You turn a one-off runtime correction into a "
+                               "durable rule for a command planner. One "
+                               "sentence. Imperative. Name the correct command "
+                               "or approach explicitly."),
+                context_block=(f"REQUEST: {item.get('request','')}\n"
+                               f"WHAT FAILED: {json.dumps(broken)[:600]}\n"
+                               f"ERROR: {item.get('error','')[:400]}\n"
+                               f"WHAT WORKED: {json.dumps(fixed)[:600]}"),
+                provider_order=["gemini", "local"],
+            )
+            rule = (getattr(rep, "text", "") or "").strip().strip('"')[:300]
+        except Exception as exc:
+            _log(f"lasting fix unavailable: {exc}")
+            break
+        if not rule:
+            continue
+        rkey = _rule_key(rule)
+        if rkey in known_rules:
+            # Same lesson, different filename. Remember the signature so it is
+            # not re-derived, but do not add the sentence twice.
+            known.add(sig)
+            continue
+        learned.append({"at": time.time(), "signature": sig, "rule": rule,
+                        "request": str(item.get("request", ""))[:200]})
+        known.add(sig)
+        known_rules.add(rkey)
+        new_rules.append(rule)
+
+    if not new_rules:
+        return []
+
+    try:
+        os.makedirs(os.path.dirname(_LEARNED_FIXES), exist_ok=True)
+        with open(_LEARNED_FIXES, "w", encoding="utf-8") as fh:
+            json.dump(learned[-200:], fh, indent=2)
+        # The queue has been distilled; clearing it stops the same entries being
+        # re-learned on every pass.
+        with open(_REPAIR_LOG, "w", encoding="utf-8") as fh:
+            json.dump([], fh)
+    except Exception as exc:
+        _log(f"could not persist learned fixes: {exc}")
+        return []
+
+    if speak:
+        n = len(new_rules)
+        speak(f"I went back and fixed {n} thing{'s' if n != 1 else ''} "
+              f"that had been going wrong: {new_rules[0]}")
+    _log(f"learned {len(new_rules)} lasting fix(es)")
+    return new_rules
+
+
+def _unmet_artifacts(request: str) -> list[str]:
+    """File paths the request clearly asked for that do not exist afterwards.
+
+    Only paths written out explicitly and unambiguously — an absolute path with
+    an extension. A request that merely MENTIONS a file it wants read is not
+    caught here, and should not be: this exists to catch "make me X" that
+    produced no X, not to guess at intent.
+    """
+    try:
+        # C:\dir\name.ext  or  /dir/name.ext — and the path must START at a
+        # boundary. Without the lookbehind, "read modules/omega_executor.py"
+        # matched "/omega_executor.py" out of the middle of a RELATIVE path and
+        # then reported a perfectly present file as missing.
+        pattern = (r"""(?:(?<=^)|(?<=[\s"'(]))"""
+                   r"""((?:[A-Za-z]:[\\/]|/)[^"'\s,;()]+\.[A-Za-z0-9]{1,6})""")
+        found = re.findall(pattern, request or "")
+    except Exception:
+        return []
+    missing = []
+    for p in dict.fromkeys(found):          # de-duplicate, keep order
+        try:
+            if not os.path.exists(p):
+                missing.append(p)
+        except Exception:
+            continue
+    return missing[:5]
+
+
 def _summarise_success(request: str, results: list[StepResult]) -> str:
     done = [r for r in results if r.ok and r.kind not in ("say",)]
     if not done:

modules/operator_memory.py

@@ -0,0 +1,143 @@
+"""
+modules/operator_memory.py — the ONE thing JARVIS knows about the operator.
+
+WHY THIS EXISTS.
+
+What he had learned about the person he works for was split across three stores
+that never met:
+
+  1. the PHONE's `JARVIS_MEMORY` (DataStore) — the "THEY: … || YOU: …" lines
+     written after every exchange. It reached exactly one place: `/api/chat`,
+     and only because the handset attached it to the request itself.
+  2. the DESKTOP's `modules/memory.py` (.friday_data/memory.json) — insights and
+     unfinished tasks. Read by `core/brain.py`, and by nothing on the phone.
+  3. the CLOUD's episodic memory — backed by ChromaDB, which is not installed
+     ("chromadb is not installed. Episodic memory will not work.").
+
+So a fact told to him on the phone was invisible to the desktop brain, to the
+autonomous initiative loop, and to research and OSINT. Asked whether he uses
+what he has learned "for literally everything", the honest answer was no: he
+used it on one path out of several, and the operator had no way to tell which.
+
+This module is the single store all of those read from and write to. It is
+deliberately plain — an append-only list of short lines with a source tag,
+deduplicated, capped, on local disk. No database to install, nothing to be
+absent at runtime, and nothing that fails differently on the Space than on the
+desktop. The failure mode that mattered here was NOT a weak store; it was three
+strong stores that could not see each other.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import threading
+import time
+from typing import Optional
+
+try:
+    from modules.paths import DATA_DIR  # type: ignore
+except Exception:
+    DATA_DIR = os.path.join(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__))), ".friday_data")
+
+_STORE = os.path.join(DATA_DIR, "operator_memory.json")
+
+# Enough to carry a person, small enough to sit in every prompt without
+# crowding out the actual question.
+MAX_LINES = 400
+PROMPT_LINES = 30
+
+_lock = threading.Lock()
+
+
+def _key(text: str) -> str:
+    """Normalise so the same fact told twice does not become two facts."""
+    return re.sub(r"[^a-z0-9]+", " ", (text or "").lower()).strip()[:160]
+
+
+def _load() -> list[dict]:
+    try:
+        with open(_STORE, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+        return data if isinstance(data, list) else []
+    except Exception:
+        return []
+
+
+def _save(rows: list[dict]) -> None:
+    try:
+        os.makedirs(os.path.dirname(_STORE), exist_ok=True)
+        tmp = _STORE + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as fh:
+            json.dump(rows[-MAX_LINES:], fh, indent=2, ensure_ascii=False)
+        os.replace(tmp, _STORE)          # atomic; a torn write loses everything
+    except Exception:
+        pass
+
+
+def remember(text: str, source: str = "chat") -> bool:
+    """Record one thing learned. Returns True if it was new.
+
+    `source` is kept because provenance matters when he is asked how he knows
+    something — "you told me on the phone" and "I observed it on the desktop"
+    are different claims and should not be reported as the same.
+    """
+    line = (text or "").strip().replace("\n", " ")
+    if len(line) < 3:
+        return False
+    line = line[:400]
+    k = _key(line)
+    with _lock:
+        rows = _load()
+        if any(_key(r.get("text", "")) == k for r in rows[-MAX_LINES:]):
+            return False
+        rows.append({"at": time.time(), "text": line, "source": source[:32]})
+        _save(rows)
+    return True
+
+
+def remember_many(lines, source: str = "chat") -> int:
+    """Absorb a batch — e.g. the whole block the phone sends each request."""
+    n = 0
+    for ln in (lines or []):
+        if remember(str(ln), source):
+            n += 1
+    return n
+
+
+def absorb_block(block: str, source: str = "phone") -> int:
+    """Absorb the phone's `learned` blob, one line per remembered exchange."""
+    if not block:
+        return 0
+    return remember_many(
+        [ln for ln in str(block).splitlines() if ln.strip()], source)
+
+
+def recall(limit: int = PROMPT_LINES) -> list[str]:
+    """The most recent things known, oldest first so the newest reads last."""
+    rows = _load()
+    return [r.get("text", "") for r in rows[-max(1, limit):] if r.get("text")]
+
+
+def recall_text(limit: int = PROMPT_LINES, header: str = "") -> str:
+    """A prompt block, or '' when nothing is known.
+
+    Returning '' rather than a header with nothing under it matters: an empty
+    "WHAT YOU KNOW ABOUT THEM:" invites the model to fill the gap.
+    """
+    lines = recall(limit)
+    if not lines:
+        return ""
+    head = header or ("WHAT YOU HAVE LEARNED ABOUT THIS OPERATOR "
+                      "(from every conversation, on every device)")
+    return f"{head}:\n" + "\n".join(f"- {ln}" for ln in lines)
+
+
+def count() -> int:
+    return len(_load())
+
+
+__all__ = ["remember", "remember_many", "absorb_block", "recall",
+           "recall_text", "count", "MAX_LINES", "PROMPT_LINES"]

modules/osint_review.py

@@ -291,7 +291,34 @@ def run_osint_review(target: str = "") -> str:
     Executes the comprehensive OSINT & Attack Surface review.
     If 'target' is provided, it scans that specific asset.
     If 'target' is empty, it loads all assets from osint_targets.json.
+
+    Collection is done by backend/omega/osint_engine.py — RDAP, certificate
+    transparency, DNS, Wayback, urlscan, OTX, InternetDB, GitHub, Gravatar,
+    Holehe-style account enumeration, Wikidata — and only the write-up is left
+    to the model, over findings it did not invent. Everything below the
+    delegation is the original prompt-only path, kept as the fallback for when
+    the engine cannot be imported at all; it produces a plausible-looking report
+    from model recall with nothing fetched, so it says so.
     """
+    try:
+        from modules.researcher import osint as _real_osint
+        if (target or "").strip():
+            return _real_osint(target.strip(), depth=2)
+        init_osint_targets()
+        with open(OSINT_TARGETS_FILE, "r", encoding="utf-8") as f:
+            bulk = json.load(f)
+        selectors = [
+            s for key in ("domains", "emails", "usernames")
+            for s in bulk.get(key, [])
+            if s and not s.startswith(("example.com", "admin@example.com", "target_alias"))
+        ]
+        if not selectors:
+            return ("No real targets configured. Give me a selector, or put "
+                    f"domains/emails/usernames in {OSINT_TARGETS_FILE}.")
+        return "\n\n".join(f"── {s} ──\n{_real_osint(s, depth=1)}" for s in selectors[:5])
+    except Exception as _engine_exc:
+        _log.error(f"Real OSINT engine unavailable, falling back: {_engine_exc}")
+
     try:
         from core.brain import _ask_gemini
         init_osint_targets()
@@ -328,7 +355,10 @@ def run_osint_review(target: str = "") -> str:
         with open(report_file, 'w', encoding='utf-8') as f:
             f.write(report)
             
-        return f"OSINT & Attack Surface Review complete. The 14-section exhaustive report has been generated and saved to {report_file}."
+        return (f"OSINT review written to {report_file}. Flagging this honestly: "
+                f"the collection engine was unreachable, so this report is model "
+                f"recall — nothing in it was fetched from a source just now, and "
+                f"none of it is corroborated.")
 
     except Exception as e:
         _log.error(f"OSINT Review failed: {e}")

modules/researcher.py

@@ -1,70 +1,176 @@
-"""
-modules/researcher.py — FRIDAY Web Research
-
-Deep research on any topic:
-- Summarize topics
-- Quick facts
-- News summaries
-- Deep dive
-"""
-
-def research(topic: str, depth: str = "quick") -> str:
-    """Research a topic."""
-    try:
-        from config import GEMINI_API_KEY, GEMINI_MODEL
-        if not GEMINI_API_KEY:
-            return "No API. Search online instead."
-
-        import google.generativeai as genai
-        genai.configure(api_key=GEMINI_API_KEY)
-        model = genai.GenerativeModel(GEMINI_MODEL)
-
-        prompt = f"{'Quick summary' if depth == 'quick' else 'In-depth research'} on: {topic}. " + (
-            "Answer in 3-4 sentences max." if depth == "quick" else "Comprehensive answer in 2 paragraphs with key points."
-        )
-
-        resp = model.generate_content(prompt)
-        return resp.text.strip()[:500]
-    except Exception as e:
-        return f"Research failed: {e}"
-
-
-def quick_fact(question: str) -> str:
-    """Get quick fact."""
-    return research(question, "quick")
-
-
-def deep_dive(topic: str) -> str:
-    """Deep research."""
-    return research(topic, "deep")
-
-
-# ── Voice Commands ────────────────────────────────────────────
-
-def handle_command(command: str, speak) -> bool:
-    """Handle research commands."""
-    c = command.lower()
-
-    # Research topic
-    if "research" in c or "find out about" in c or "what is " in c or "who is " in c:
-        topic = c.replace("research", "").replace("find out about", "").replace("what is", "").replace("who is", "").strip()
-
-        if topic and len(topic) > 2:
-            if "deep" in c or "detailed" in c or "in depth" in c:
-                result = deep_dive(topic)
-            else:
-                result = quick_fact(topic)
-
-            speak(result)
-            return True
-
-    # Quick question
-    if "what's " in c or "who's " in c or "where " in c:
-        # Basic factual questions
-        topic = c
-        if topic:
-            result = quick_fact(topic)
-            speak(result)
-            return True
-
-    return False
+"""
+modules/researcher.py — desktop research, routed to the real engines.
+
+This module used to be the whole of "research" on the PC: one Gemini call with
+no web access, truncated to 500 characters. It answered from model recall and
+called that research, which is exactly the complaint that the desktop "does
+research like a normal model would". Meanwhile backend/omega/research_engine.py
+(live search + fetch + analysis) and backend/omega/osint_engine.py (real
+collection, pivoting and multi-source corroboration) were already serving the
+phone and the Space.
+
+So this file is now a thin router onto those two, and the offline fallback is
+labelled as recall so nobody mistakes it for a source.
+"""
+
+import logging
+import re
+
+_log = logging.getLogger(__name__)
+
+# A person, a domain, an email, a handle — the things worth investigating rather
+# than merely reading about.
+_SELECTOR = re.compile(
+    r"(?:^|\s)(?:"
+    r"[\w.+-]+@[\w-]+\.[\w.]+"                    # email
+    r"|(?:https?://)?(?:[\w-]+\.)+[a-z]{2,}(?:/\S*)?"  # domain / url
+    r"|@[\w.-]{3,}"                                # handle
+    r"|\d{1,3}(?:\.\d{1,3}){3}"                    # ipv4
+    r")(?:\s|$)",
+    re.IGNORECASE,
+)
+
+_OSINT_WORDS = (
+    "osint", "investigate", "dig into", "background check", "footprint",
+    "who owns", "whois", "breach", "leaked", "profile of", "trace",
+)
+
+
+def _run_async(coro, timeout: float = 240.0):
+    """Run a coroutine from sync code, loop or no loop. See tool_registry."""
+    import asyncio
+
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(asyncio.wait_for(coro, timeout))
+
+    import concurrent.futures
+
+    def _worker():
+        return asyncio.run(asyncio.wait_for(coro, timeout))
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+        return pool.submit(_worker).result(timeout=timeout + 30)
+
+
+def _recall(topic: str) -> str:
+    """Last resort when nothing can be fetched. Labelled, never disguised."""
+    try:
+        from config import GEMINI_API_KEY, GEMINI_MODEL
+        if not GEMINI_API_KEY:
+            return ("I could not reach the web and I have no model key either, "
+                    "so I have nothing sourced to give you on that.")
+        import google.generativeai as genai
+        genai.configure(api_key=GEMINI_API_KEY)
+        model = genai.GenerativeModel(GEMINI_MODEL)
+        resp = model.generate_content(
+            f"Answer concisely: {topic}. If you are not confident, say so."
+        )
+        return ("From memory, not from a source I just checked — "
+                + resp.text.strip())
+    except Exception as exc:
+        _log.error("Recall fallback failed", exc_info=exc)
+        return f"I could not research that: {exc}"
+
+
+def research(topic: str, depth: str = "quick") -> str:
+    """Research a topic against the live web."""
+    topic = (topic or "").strip()
+    if not topic:
+        return "What would you like me to research?"
+    try:
+        from backend.omega.research_engine import research_topic
+        note = _run_async(research_topic(topic), timeout=240.0)
+        body = (getattr(note, "summary", "") or "").strip()
+        if body:
+            if depth == "quick":
+                # First two paragraphs is a spoken-length answer; the stored
+                # note keeps the whole thing for anything that wants to read it.
+                parts = [p for p in body.split("\n\n") if p.strip()]
+                if parts:
+                    body = "\n\n".join(parts[:2])
+            action = (getattr(note, "recommended_action", "") or "").strip()
+            if depth != "quick" and action:
+                body += f"\n\nRecommended: {action}"
+            source = (getattr(note, "source", "") or "").strip()
+            if source:
+                body += f"\n\nSource: {source}"
+            return body.strip()
+        _log.warning("Research engine returned an empty note for %r", topic)
+    except Exception as exc:
+        _log.error("Research engine unavailable", exc_info=exc)
+    return _recall(topic)
+
+
+def osint(target: str, depth: int = 2) -> str:
+    """Full investigation on a selector — the real collector, not a prompt."""
+    target = (target or "").strip()
+    if not target:
+        return "Give me a selector to investigate."
+    try:
+        from backend.omega.osint_engine import brief, investigate
+        report = _run_async(investigate(target, depth=depth), timeout=300.0)
+        if report.get("error"):
+            return f"OSINT failed: {report['error']}"
+        return brief(report)
+    except Exception as exc:
+        _log.error("OSINT engine unavailable", exc_info=exc)
+        return f"OSINT failed: {exc}"
+
+
+def quick_fact(question: str) -> str:
+    return research(question, "quick")
+
+
+def deep_dive(topic: str) -> str:
+    return research(topic, "deep")
+
+
+# ── Voice Commands ────────────────────────────────────────────
+
+_PREFIXES = (
+    "run osint on", "osint on", "osint", "investigate", "background check on",
+    "background check", "dig into", "research", "find out about", "find out",
+    "look up", "tell me about", "what is", "what's", "who is", "who's",
+)
+
+
+def _strip_prefix(text: str) -> str:
+    low = text.lower()
+    for p in _PREFIXES:
+        if low.startswith(p + " "):
+            return text[len(p) + 1:].strip(" ?.")
+    return text.strip(" ?.")
+
+
+def handle_command(command: str, speak) -> bool:
+    """Handle research/OSINT commands. Returns False if this is not one.
+
+    Returning False matters: core/commands.py used to swallow every "what is"
+    and "who is" here whatever happened, so anything this module declined died
+    silently instead of reaching the brain.
+    """
+    text = (command or "").strip()
+    if not text:
+        return False
+    low = text.lower()
+
+    wants_osint = any(w in low for w in _OSINT_WORDS)
+    wants_research = any(
+        low.startswith(p) or f" {p} " in f" {low} " for p in _PREFIXES
+    )
+    if not (wants_osint or wants_research):
+        return False
+
+    topic = _strip_prefix(text)
+    if len(topic) < 3:
+        return False
+
+    if wants_osint or _SELECTOR.search(f" {topic} "):
+        speak(osint(topic))
+        return True
+
+    deep = any(w in low for w in ("deep", "detailed", "in depth", "thorough"))
+    speak(deep_dive(topic) if deep else quick_fact(topic))
+    return True

modules/tool_registry.py

@@ -355,15 +355,92 @@ def _make_security_review_fn() -> Callable:
             return f"Security review failed: {str(_friday_exc)}"
     return execute_security_review
 
-def _make_osint_review_fn() -> Callable:
-    def execute_osint_review(target: str = "") -> str:
+def _run_async(coro, timeout: float = 300.0):
+    """Run a coroutine from a synchronous tool function.
+
+    The registry is called from two very different places: the desktop brain
+    (plain sync code, no loop) and the ReAct agent (already inside a running
+    loop). asyncio.run() explodes in the second case, so when a loop is already
+    turning in this thread the work goes to a private loop on a worker thread.
+    """
+    import asyncio
+
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(asyncio.wait_for(coro, timeout))
+
+    import concurrent.futures
+
+    def _worker():
+        return asyncio.run(asyncio.wait_for(coro, timeout))
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+        return pool.submit(_worker).result(timeout=timeout + 30)
+
+
+def _make_osint_fn() -> Callable:
+    def execute_osint(target: str = "", depth: str = "2") -> str:
+        """Real collection, not a prompt.
+
+        The tool this replaced handed the target to Gemini and asked it to
+        "execute Phases 1-10 and output the final 14-section report" — no RDAP,
+        no certificate transparency, no DNS, no account enumeration, nothing
+        fetched from anywhere. The model wrote what an OSINT report looks like.
+        That is the "he does OSINT like a normal model" the operator reported,
+        and it was only ever true on the desktop: the phone and the Space have
+        been on backend/omega/osint_engine.py since it was written.
+        """
+        target = (target or "").strip()
+        if not target:
+            return ("OSINT needs a selector — a domain, email, username, IP, "
+                    "phone number or a person's name. Give me one to work from.")
+        try:
+            depth_n = max(0, min(3, int(str(depth).strip() or 2)))
+        except Exception:
+            depth_n = 2
         try:
-            from modules.osint_review import run_osint_review
-            return run_osint_review(target)
+            from backend.omega.osint_engine import brief, investigate
+            report = _run_async(investigate(target, depth=depth_n), timeout=300.0)
+            if report.get("error"):
+                return f"OSINT failed: {report['error']}"
+            return brief(report)
         except Exception as _friday_exc:
-            _log.error('Failed to run OSINT review', exc_info=_friday_exc)
-            return f"OSINT review failed: {str(_friday_exc)}"
-    return execute_osint_review
+            _log.error('Failed to run OSINT investigation', exc_info=_friday_exc)
+            return f"OSINT failed: {str(_friday_exc)}"
+    return execute_osint
+
+
+def _make_image_forensics_fn() -> Callable:
+    def analyse_image_file(path: str = "", online: str = "false") -> str:
+        """Full forensic pass over a local image file.
+
+        `online` stays off unless the operator asks for it, because a reverse
+        image search PUBLISHES the picture to whichever engine answers it.
+        """
+        import os
+
+        path = (path or "").strip().strip('"').strip("'")
+        if not path:
+            return "Give me the path to an image file."
+        if not os.path.isfile(path):
+            return f"No such file: {path}"
+        want_online = str(online).strip().lower() in ("1", "true", "yes", "on", "online")
+        try:
+            with open(path, "rb") as fh:
+                data = fh.read()
+            from backend.tools.image_forensics import analyse_image, summarise
+            report = _run_async(
+                analyse_image(data, os.path.basename(path), online=want_online),
+                timeout=240.0,
+            )
+            if report.get("error"):
+                return f"Image analysis failed: {report['error']}"
+            return summarise(report)
+        except Exception as _friday_exc:
+            _log.error('Failed to analyse image', exc_info=_friday_exc)
+            return f"Image analysis failed: {str(_friday_exc)}"
+    return analyse_image_file
 
 
 def _build_default_tools() -> list[ToolSpec]:
@@ -513,13 +590,38 @@ def _build_default_tools() -> list[ToolSpec]:
             error_recovery='Return "Security review failed to initialize"',
         ),
         ToolSpec(
-            name='run_osint_review',
-            description='Executes an Elite OSINT and Attack Surface Reduction assessment on a target (domain, email, username). Pass empty string to bulk scan targets in osint_targets.json.',
+            name='run_osint',
+            description=(
+                'Real OSINT investigation on a selector (domain, email, username, IP, '
+                'phone or person name). Collects from RDAP, certificate transparency, '
+                'DNS, Wayback, urlscan, OTX, Shodan InternetDB, GitHub, Gravatar, '
+                'Holehe-style account enumeration, Wikidata and Wikipedia, then pivots '
+                'on what it finds and grades every assertion LEAD/CORROBORATED/'
+                'CONFIRMED by how many independent sources carry it. depth 0=target '
+                'only, 2=default, 3=deepest.'
+            ),
             category='web',
-            fn=_make_osint_review_fn(),
-            input_schema={'target': 'str'},
+            fn=_make_osint_fn(),
+            input_schema={'target': 'str', 'depth': 'str'},
+            output_type='str',
+            error_recovery='Return "OSINT failed to initialize"',
+        ),
+        ToolSpec(
+            name='analyse_image',
+            description=(
+                'Forensic analysis of an image file on this PC: all metadata (EXIF/GPS/'
+                'XMP/IPTC/maker notes), hidden data (LSB steganography, appended '
+                'payloads, embedded file magics), watermarks (visible, frequency-domain '
+                'and invisible), error level analysis, copy-move/clone detection, noise '
+                'consistency, perceptual hashes and face count. Pass online=true to also '
+                'reverse image search and geolocate — that publishes the picture, so only '
+                'do it when the operator asked.'
+            ),
+            category='file',
+            fn=_make_image_forensics_fn(),
+            input_schema={'path': 'str', 'online': 'str'},
             output_type='str',
-            error_recovery='Return "OSINT review failed to initialize"',
+            error_recovery='Return "Image analysis failed to initialize"',
         ),
     ]