witbitz-code 1.6.0__tar.gz → 1.6.2__tar.gz

{witbitz_code-1.6.0/src/witbitz_code.egg-info → witbitz_code-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.6.0
+Version: 1.6.2
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT

{witbitz_code-1.6.0 → witbitz_code-1.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.6.0"
+version = "1.6.2"
 description = "Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -43,7 +43,7 @@ where = ["src"]
 
 # Our OpenCode plugins, installed by `serve` (plugins.py) — copies of tools/opencode-plugins, kept current by embed.mjs
 [tool.setuptools.package-data]
-witbitz_code = ["opencode_plugins/*", "confidential_models.json", "offered_models.json", "tools_catalog.json", "ui_static/*"]
+witbitz_code = ["opencode_plugins/*", "confidential_models.json", "offered_models.json", "tools_catalog.json", "ui_static/*", "icons/*"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{witbitz_code-1.6.0 → witbitz_code-1.6.2}/src/witbitz_code/__init__.py

@@ -4,4 +4,4 @@ The Python implementation of tools/witbitz-code.mjs (docs/opencode-relay.md phas
 vectors and cross-implementation tests.
 """
 
-__version__ = "1.6.0"
+__version__ = "1.6.2"

{witbitz_code-1.6.0 → witbitz_code-1.6.2}/src/witbitz_code/uninstall.py

@@ -23,7 +23,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-from . import keys, plugins
+from . import keys, plugins, ports
 from . import pairings as pp
 from .wizard import find_opencode
 
@@ -138,6 +138,8 @@ def opencode_holders(data_dir: str) -> list[dict]:
                 cmd = ""
             hits.append({"pid": int(p), "cmd": cmd})
         return hits
+    if sys.platform == "win32":  # no /proc, no lsof: every opencode.exe of this user's (the owner, 2026-10-09: the background
+        return win_opencode_processes()  # copy's OpenCode held opencode.db and the delete died "WinError 32")
     files = [os.path.join(data_dir, f) for f in ("opencode.db", "opencode.db-wal", "opencode.db-shm") if os.path.exists(os.path.join(data_dir, f))]
     if not files or not shutil.which("lsof"):
         return hits
@@ -150,6 +152,55 @@ def opencode_holders(data_dir: str) -> list[dict]:
     return hits
 
 
+def win_opencode_processes(*, run: Callable[[list[str]], str] | None = None, user: str | None = None) -> list[dict]:
+    """Windows: this user's opencode.exe processes (tasklist, one CSV row each)."""
+    run = run or ports._run_text
+    user = os.environ.get("USERNAME", "") if user is None else user
+    hits = []
+    for line in run(["tasklist", "/V", "/FO", "CSV", "/NH", "/FI", "IMAGENAME eq opencode.exe"]).splitlines():
+        row = ports.parse_tasklist_row(line)
+        if row and (not user or row["user"].rsplit("\\", 1)[-1].lower() == user.lower()):
+            hits.append({"pid": row["pid"], "cmd": row["image"]})
+    return hits
+
+
+def running_witbitz(*, lock: Path | None = None, pairings: Callable[[], list] | None = None,
+                    owners: Callable[[int], list] | None = None, alive: Callable[[int], bool] | None = None) -> list[dict]:
+    """What runs witbitz-code here now: the page's manager (its ui.json names it — in the background it has no window to
+    close) and whatever holds each paired OpenCode port or its model proxy's (port + 100): a serve, its OpenCode."""
+    lock = lock or pp.pairings_path().parent / "ui.json"
+    pairings = pairings or (lambda: pp.load_pairings(log=lambda _m: None))
+    owners = owners or ports.port_owners
+    alive = alive or _alive
+    found: list[dict] = []
+    try:
+        pid = json.loads(lock.read_text(encoding="utf-8")).get("pid")
+        if isinstance(pid, int) and pid != os.getpid() and alive(pid):
+            found.append({"pid": pid, "cmd": "the Witbitz Code page"})
+    except (OSError, ValueError, AttributeError):
+        pass
+    for p in pairings():
+        tail = str(p.get("opencodeUrl") or "").rsplit(":", 1)[-1].rstrip("/")
+        port = int(tail) if tail.isdigit() else 0
+        for q in ([port, port + 100] if port else []):
+            for o in owners(q):
+                if o["pid"] != os.getpid() and all(o["pid"] != x["pid"] for x in found):
+                    found.append({"pid": int(o["pid"]), "cmd": str(o.get("cmd") or "")[:70]})
+    return found
+
+
+def _alive(pid: int) -> bool:
+    if sys.platform == "win32":
+        return _win_alive(pid)
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return False  # another user's: not ours
+
+
 def _win_alive(pid: int) -> bool:
     """Windows: is `pid` still running? (OpenProcess + GetExitCodeProcess; access denied = another user's, still running.)"""
     import ctypes  # noqa: PLC0415 — Windows only
@@ -287,6 +338,7 @@ class Deps:
     sessions: Callable[[], dict] = None  # type: ignore[assignment]
     delete_sessions: Callable[[], None] = None  # type: ignore[assignment]
     opencode_processes: Callable[[], list] = lambda: opencode_holders(str(keys.auth_path().parent))
+    running: Callable[[], list] = running_witbitz
     stop_process: Callable[[int], bool] = stop_process
     opencode: Callable[[], dict] = opencode_here
     remove_opencode_program: Callable[[dict], dict] = remove_opencode_program
@@ -332,6 +384,12 @@ async def run_uninstall(d: Deps) -> dict:
     how = {"installer": "from OpenCode's installer, in ~/.opencode", "npm": "with npm", "brew": "with Homebrew"}.get(oc["kind"])
     remove_oc = ask(d.remove_opencode, f"Also remove OpenCode itself (installed {how})? [y/N] ") if oc["kind"] not in ("none", "other") else False
 
+    # The running witbitz-code first — the page's manager in the background, a serve, their OpenCode: it holds the files
+    # about to go (Windows refuses to delete an open file) and would keep answering the phone. Continue already said yes.
+    for p in d.running():
+        d.say(f"✓ Stopped the running witbitz-code: {p['cmd'] or 'a program'} (process {p['pid']})" if d.stop_process(p["pid"])
+              else f"✖ Could not stop {p['cmd'] or 'a program'} (process {p['pid']}) — close it, then run uninstall again")
+
     # Sessions: an OpenCode that has its database open would write it back — never delete under it.
     while remove_sessions:
         procs = d.opencode_processes()
@@ -376,8 +434,11 @@ async def run_uninstall(d: Deps) -> dict:
         d.remove_path(notes["root"])
         d.say(f"✓ Deleted {notes['root']}")
     if remove_sessions:
-        d.delete_sessions()
-        d.say(f"✓ Deleted the OpenCode sessions in {sessions['dir']} (provider logins kept)")
+        stuck = d.delete_sessions() or []
+        if stuck:
+            d.say(f"✖ Could not delete {', '.join(stuck[:4])} in {sessions['dir']} — another program still has it open; close OpenCode and delete it yourself")
+        else:
+            d.say(f"✓ Deleted the OpenCode sessions in {sessions['dir']} (provider logins kept)")
     oc_gone = False
     if remove_oc:
         try:
@@ -454,12 +515,18 @@ def sessions_info() -> dict:
     return {"dir": str(d), "exists": exists}
 
 
-def delete_sessions() -> None:
+def delete_sessions() -> list[str]:
+    """→ the names that could not be deleted (Windows: a file another program still has open), never a crash."""
     d = keys.auth_path().parent
+    left = []
     for f in d.iterdir():
         if f.name == "auth.json":
             continue
-        shutil.rmtree(f, ignore_errors=True) if f.is_dir() and not f.is_symlink() else f.unlink(missing_ok=True)
+        try:
+            shutil.rmtree(f, ignore_errors=True) if f.is_dir() and not f.is_symlink() else f.unlink(missing_ok=True)
+        except OSError:
+            left.append(f.name)
+    return left
 
 
 def saved_keys() -> list[str]:

{witbitz_code-1.6.0 → witbitz_code-1.6.2}/src/witbitz_code/wslstart.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 import base64
 import getpass
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -50,6 +51,31 @@ def wsl_args(distro: str, user: str, cmd: list[str], verb: list[str] | None = No
     return _join(parts)
 
 
+_SAFE_DIR = re.compile(r"[A-Za-z0-9_./+:@-]+")
+
+
+def carried_path(path: str | None = None) -> str:
+    """This terminal's PATH for a start that runs the command directly — wsl.exe's `--` reads no ~/.bashrc, so a hidden copy
+    had only the system folders: no OpenCode (nvm's, ~/.opencode/bin), no witbitz-code (the owner, 2026-10-09: "OpenCode is
+    not installed" and "Start when I log in — not available"). Only plain folder names cross the Windows command line."""
+    parts = (os.environ.get("PATH", "") if path is None else path).split(":")
+    return ":".join(dict.fromkeys(p for p in parts if p and _SAFE_DIR.fullmatch(p) and ":" not in p))
+
+
+def wsl_command(exe: str, path: str | None = None) -> list[str]:
+    """[env, PATH=…, exe] — the command a hidden start runs, with this terminal's PATH."""
+    return ["env", "PATH=" + carried_path(path), exe]
+
+
+def this_program() -> str:
+    """witbitz-code on PATH, else the program running now (a hidden copy started before 1.6.2 had no ~/.local/bin)."""
+    exe = shutil.which("witbitz-code")
+    if exe:
+        return exe
+    argv0 = os.path.abspath(sys.argv[0]) if sys.argv and sys.argv[0] else ""
+    return argv0 if argv0 and os.path.basename(argv0) == "witbitz-code" and os.path.exists(argv0) else ""
+
+
 def headless_args(distro: str, user: str, cmd: list[str], verb: list[str]) -> str:
     """conhost.exe's arguments: no window, then wsl.exe with wsl_args."""
     return "--headless wsl.exe " + wsl_args(distro, user, cmd, verb)
@@ -59,11 +85,52 @@ def _q(s: str) -> str:  # a PowerShell single-quoted string
     return "'" + s.replace("'", "''") + "'"
 
 
-def enable_script(name: str, args: str, folder: str = STARTUP, target: str = WSL_EXE) -> str:
-    """`target` is a PowerShell expression (wsl.exe), or a path made one with _q (native Windows: the launcher)."""
+def enable_script(name: str, args: str, folder: str = STARTUP, target: str = WSL_EXE, icon: str = "") -> str:
+    """`target` is a PowerShell expression (wsl.exe), or a path made one with _q (native Windows: the launcher). `icon`: a
+    PowerShell expression for an .ico (else the target's own icon — a console window's, for conhost)."""
     return (f"$p = Join-Path ({folder}) {_q(name)}; $s = (New-Object -ComObject WScript.Shell).CreateShortcut($p); "
             f"$s.TargetPath = {target}; $s.Arguments = {_q(args)}; $s.WorkingDirectory = $env:USERPROFILE; $s.WindowStyle = 7; "
-            "$s.Description = 'Witbitz Code'; $s.Save(); 'ok'")
+            + (f"if (Test-Path ({icon})) {{ $s.IconLocation = ({icon}) + ',0' }}; " if icon else "")
+            + "$s.Description = 'Witbitz Code'; $s.Save(); 'ok'")
+
+
+# The shortcuts' icons (icons/ in this package; the owner, 2026-10-09: the WSL entry "has a terminal icon"). WSL's is
+# copied to a Windows folder of its own — not under %LOCALAPPDATA%\Witbitz, which the Windows copy's uninstall deletes.
+ICON_DIR = "(Join-Path $env:LOCALAPPDATA 'Witbitz-WSL')"
+WSL_ICON = f"(Join-Path {ICON_DIR} 'witbitz-code-wsl.ico')"
+
+
+def icon_file(name: str) -> str:
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "icons", name)
+
+
+def linux_path(windows: str, run: Callable = subprocess.run) -> str:
+    """wslpath -u — '' when it cannot say."""
+    try:
+        r = run(["wslpath", "-u", windows], capture_output=True, text=True, timeout=10)
+        return (r.stdout or "").strip() if r.returncode == 0 else ""
+    except (OSError, subprocess.SubprocessError):
+        return ""
+
+
+def copy_icon(*, ps: Callable[[str], tuple[int, str]] | None = None, to_linux: Callable[[str], str] = linux_path,
+              src: str | None = None) -> bool:
+    """Put WSL's icon in its Windows folder, written from THIS side through /mnt/c (Windows could not read the
+    \\\\wsl.localhost path of the package on the owner's laptop: "does not exist"). → whether it is there now."""
+    src = src or icon_file("witbitz-code-wsl.ico")
+    code, out = (ps or run_ps)("$env:LOCALAPPDATA")
+    local = out.splitlines()[-1].strip() if code == 0 and out else ""
+    if not re.fullmatch(r"[A-Za-z]:\\[^\x00-\x1f]+", local):  # only a real Windows folder ("C:\Users\…\Local")
+        return False
+    dest_dir = to_linux(local)
+    if not dest_dir or not os.path.isabs(dest_dir) or not os.path.exists(src):
+        return False
+    try:
+        os.makedirs(os.path.join(dest_dir, "Witbitz-WSL"), exist_ok=True)
+        shutil.copyfile(src, os.path.join(dest_dir, "Witbitz-WSL", "witbitz-code-wsl.ico"))
+        return True
+    except OSError:
+        return False
 
 
 def state_script(name: str, folder: str = STARTUP) -> str:
@@ -101,11 +168,12 @@ def startup_here() -> dict | None:
     """What the WSL shortcut would be — None off WSL, with no Windows PowerShell to write it, or no witbitz-code on PATH."""
     if not ports.on_wsl() or not (os.path.exists(POWERSHELL) or shutil.which("powershell.exe")):
         return None
-    exe = shutil.which("witbitz-code")
+    exe = this_program()
     if not exe:
         return None
     distro = os.environ.get("WSL_DISTRO_NAME", "")
-    return {"name": shortcut_name(distro), "args": headless_args(distro, getpass.getuser(), [exe], UI_QUIET), "target": CONHOST}
+    return {"name": shortcut_name(distro), "args": headless_args(distro, getpass.getuser(), wsl_command(exe), UI_QUIET), "target": CONHOST,
+            "icon": WSL_ICON}
 
 
 def menu_name(distro: str) -> str:
@@ -119,7 +187,7 @@ def launch_script(args: str) -> str:
 
 
 def launch_background(*, ps: Callable[[str], tuple[int, str]] = run_ps, which: Callable[[str], str | None] = shutil.which,
-                      on_wsl: Callable[[], bool] = ports.on_wsl) -> tuple[bool, str]:
+                      on_wsl: Callable[[], bool] = ports.on_wsl, copy: Callable[..., bool] | None = None) -> tuple[bool, str]:
     """WSL: start the page's manager with no window, held by a hidden wsl.exe on the Windows side, and let it open the
     page in the Windows browser — setup's hand-off (this terminal may then close). → (ok, why)."""
     if not on_wsl():
@@ -127,14 +195,16 @@ def launch_background(*, ps: Callable[[str], tuple[int, str]] = run_ps, which: C
     exe = which("witbitz-code")
     if not exe:
         return False, "witbitz-code is not on PATH"
+    copy = copy or copy_icon
     distro = os.environ.get("WSL_DISTRO_NAME", "")
-    args = headless_args(distro, getpass.getuser(), [exe], ["ui", "--hidden"])
+    args = headless_args(distro, getpass.getuser(), wsl_command(exe), ["ui", "--hidden"])
     # The Start-menu entry first (it opens this page again, starting it if it is not running), then the start itself.
-    menu = enable_script(menu_name(distro), args, folder=PROGRAMS, target=CONHOST)
+    icon = WSL_ICON if copy(ps=ps) else ""
+    menu = enable_script(menu_name(distro), args, folder=PROGRAMS, target=CONHOST, icon=icon)
     # A login start written by 1.4.0–1.5.x opens a minimized window: an existing one is rewritten to start hidden too.
-    quiet = headless_args(distro, getpass.getuser(), [exe], UI_QUIET)
+    quiet = headless_args(distro, getpass.getuser(), wsl_command(exe), UI_QUIET)
     login = (f"if (Test-Path (Join-Path ({STARTUP}) {_q(shortcut_name(distro))})) {{ "
-             f"{enable_script(shortcut_name(distro), quiet, target=CONHOST)} | Out-Null }}")
+             f"{enable_script(shortcut_name(distro), quiet, target=CONHOST, icon=icon)} | Out-Null }}")
     code, out = ps(f"try {{ {menu} | Out-Null; {login} }} catch {{ }}; {launch_script(args)}")
     ok = code == 0 and bool(out) and out.splitlines()[-1].strip() == "ok"
     return ok, "" if ok else ("Windows PowerShell could not be started" if code == -1 else f"Windows PowerShell answered {code}")
@@ -148,7 +218,8 @@ def windows_startup_spec(env: dict | None = None, which: Callable[[str], str | N
     env = os.environ if env is None else env
     pyw = os.path.join(os.path.dirname(executable or sys.executable), "pythonw.exe")
     if exists(pyw):
-        return {"name": "Witbitz Code.lnk", "args": _join(["-m", "witbitz_code", *WIN_QUIET]), "target": _q(pyw)}
+        return {"name": "Witbitz Code.lnk", "args": _join(["-m", "witbitz_code", *WIN_QUIET]), "target": _q(pyw),
+                "icon": _q(icon_file("witbitz-code.ico"))}
     launcher = os.path.join(env.get("LOCALAPPDATA", ""), "Witbitz", "Witbitz Code.cmd")
     if env.get("LOCALAPPDATA") and exists(launcher):
         return {"name": "Witbitz Code.lnk", "args": "--no-browser", "target": _q(launcher)}
@@ -171,7 +242,7 @@ def startup_state(spec: dict, *, ps: Callable[[str], tuple[int, str]] = run_ps)
 
 
 def startup_enable(spec: dict, *, ps: Callable[[str], tuple[int, str]] = run_ps) -> tuple[bool, str]:
-    code, out = ps(enable_script(spec["name"], spec["args"], target=spec.get("target", WSL_EXE)))
+    code, out = ps(enable_script(spec["name"], spec["args"], target=spec.get("target", WSL_EXE), icon=spec.get("icon", "")))
     ok = code == 0 and out.splitlines()[-1].strip() == "ok" if out else False
     return ok, "" if ok else (f"Windows PowerShell answered {code}" if code != -1 else "Windows PowerShell could not be started")
 

{witbitz_code-1.6.0 → witbitz_code-1.6.2/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.6.0
+Version: 1.6.2
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT

{witbitz_code-1.6.0 → witbitz_code-1.6.2}/src/witbitz_code.egg-info/SOURCES.txt

@@ -56,6 +56,8 @@ src/witbitz_code.egg-info/dependency_links.txt
 src/witbitz_code.egg-info/entry_points.txt
 src/witbitz_code.egg-info/requires.txt
 src/witbitz_code.egg-info/top_level.txt
+src/witbitz_code/icons/witbitz-code-wsl.ico
+src/witbitz_code/icons/witbitz-code.ico
 src/witbitz_code/opencode_plugins/notes-init.md
 src/witbitz_code/opencode_plugins/witbitz-media-server.mjs
 src/witbitz_code/opencode_plugins/witbitz-notes.js

{witbitz_code-1.6.0 → witbitz_code-1.6.2}/tests/test_uninstall.py

@@ -72,7 +72,7 @@ class Fake:
             remove_opencode_program=lambda info: self.done.append(("opencode",)) or {"ok": True, "said": []},
             package=lambda: {"kind": self._pkg, "hint": "python3 -m pip uninstall witbitz-code"},
             remove_package=lambda info: self.done.append(("package",)) or {"ok": True},
-            **{"login_start": lambda: None, "menu_remove": lambda: False, **over})  # never this machine's Windows Startup folder or Start menu
+            **{"login_start": lambda: None, "menu_remove": lambda: False, "running": lambda: [], **over})  # never this machine's Windows Startup folder or Start menu
 
 
 PAIR = {"name": "desk", "account": "a@x.com", "idx": {"room": "r"}, "computerId": "c"}
@@ -174,3 +174,39 @@ def test_on_wsl_the_windows_startup_shortcut_setup_made_goes_too():
     assert gone == ["Witbitz Code (WSL UbuntuD).lnk", "menu"]
     assert any('Removed "Witbitz Code (WSL UbuntuD)" from the Start menu' in line for line in f.said)
     assert any('Removed the Windows Startup shortcut "Witbitz Code (WSL UbuntuD)"' in line for line in f.said)
+
+
+def test_the_running_witbitz_code_is_stopped_before_anything_is_deleted():
+    """The owner, 2026-10-09 (Windows): the background copy's OpenCode held opencode.db and the delete died WinError 32."""
+    f = Fake(pairs=[PAIR], sessions=True, answers=["y", "y"])
+    run(un.run_uninstall(f.deps(running=lambda: [{"pid": 8420, "cmd": "the Witbitz Code page"}, {"pid": 19228, "cmd": "opencode.exe"}])))
+    stops = [i for i, x in enumerate(f.done) if x[0] == "stop"]
+    assert [f.done[i] for i in stops] == [("stop", 8420), ("stop", 19228)]
+    assert stops[-1] < f.done.index(("sessions",)) and stops[-1] < f.done.index(("rm", "/h/.witbitz/code"))
+    assert any("Stopped the running witbitz-code: the Witbitz Code page (process 8420)" in line for line in f.said)
+
+
+def test_a_session_file_still_open_is_said_not_a_crash():
+    f = Fake(sessions=True, answers=["y", "y"])
+    d = f.deps()
+    d.delete_sessions = lambda: ["opencode.db"]
+    r = run(un.run_uninstall(d))
+    assert r.get("done") is not False
+    assert any("Could not delete opencode.db" in line for line in f.said)
+
+
+def test_what_runs_witbitz_code_is_the_page_s_manager_and_the_paired_ports_owners(tmp_path):
+    lock = tmp_path / "ui.json"
+    lock.write_text('{"port": 4290, "token": "t", "pid": 8420}')
+    owners = {4097: [{"pid": 19228, "cmd": "opencode.exe"}], 4197: [{"pid": 8420, "cmd": "python.exe"}]}
+    got = un.running_witbitz(lock=lock, pairings=lambda: [{"opencodeUrl": "http://127.0.0.1:4097"}],
+                             owners=lambda q: owners.get(q, []), alive=lambda pid: pid == 8420)
+    assert got == [{"pid": 8420, "cmd": "the Witbitz Code page"}, {"pid": 19228, "cmd": "opencode.exe"}]
+    lock.write_text('{"pid": 8420}')
+    assert un.running_witbitz(lock=lock, pairings=lambda: [], owners=lambda q: [], alive=lambda pid: False) == []
+
+
+def test_windows_finds_opencode_by_name():
+    out = '"opencode.exe","19228","Console","1","95,000 K","Running","ALONASUS\\shter","0:00:03","N/A"\n' \
+          '"opencode.exe","555","Console","1","1 K","Running","OTHER\\bob","0:00:01","N/A"\n'
+    assert un.win_opencode_processes(run=lambda argv: out, user="shter") == [{"pid": 19228, "cmd": "opencode.exe"}]

{witbitz_code-1.6.0 → witbitz_code-1.6.2}/tests/test_wslstart.py

@@ -47,7 +47,8 @@ def test_the_windows_login_start_runs_pythonw_in_the_background_when_it_is_there
     exe = r"C:\Users\a\AppData\Local\Witbitz\tools\witbitz-code\Scripts\python.exe"
     pyw = __import__("os").path.join(__import__("os").path.dirname(exe), "pythonw.exe")
     spec = ws.windows_startup_spec(env={"LOCALAPPDATA": r"C:\Users\a\AppData\Local"}, exists=lambda p: p == pyw, executable=exe)
-    assert spec == {"name": "Witbitz Code.lnk", "args": "-m witbitz_code ui --no-browser", "target": "'" + pyw + "'"}
+    assert {k: spec[k] for k in ("name", "args", "target")} == {"name": "Witbitz Code.lnk", "args": "-m witbitz_code ui --no-browser", "target": "'" + pyw + "'"}
+    assert spec["icon"].endswith("witbitz-code.ico'"), "the robot, not the launcher's icon"
     launcher_only = ws.windows_startup_spec(env={"LOCALAPPDATA": "L"}, exists=lambda p: p.endswith("Witbitz Code.cmd"), executable=exe)
     assert launcher_only["args"] == "--no-browser" and launcher_only["target"].endswith("Witbitz Code.cmd'")
 
@@ -56,12 +57,46 @@ def test_wsl_runs_headless_held_by_a_hidden_wsl_exe():
     from witbitz_code import wslstart as ws
     seen = []
     ok, why = ws.launch_background(ps=lambda script: seen.append(script) or (0, "ok"), which=lambda n: "/home/a/.local/bin/witbitz-code",
-                                   on_wsl=lambda: True)
+                                   on_wsl=lambda: True, copy=lambda ps: False)
     assert ok and why == ""
     assert "GetFolderPath('Programs')" in seen[0] and "'Witbitz Code (WSL " in seen[0], "its own Start-menu entry"
     assert seen[0].index("Programs") < seen[0].index("Start-Process"), "the entry is written before the start"
     assert "if (Test-Path (Join-Path ([Environment]::GetFolderPath('Startup'))" in seen[0], "an older login start is rewritten hidden"
-    assert "conhost.exe" in seen[0] and "'--headless wsl.exe " in seen[0] and "-- /home/a/.local/bin/witbitz-code ui --hidden'" in seen[0]
+    assert "conhost.exe" in seen[0] and "'--headless wsl.exe " in seen[0] and " /home/a/.local/bin/witbitz-code ui --hidden'" in seen[0] and "-- env PATH=" in seen[0]
     assert ws.launch_background(ps=lambda s: (0, "ok"), on_wsl=lambda: False) == (False, "not in WSL")
-    assert ws.launch_background(ps=lambda s: (1, ""), which=lambda n: "/w", on_wsl=lambda: True) == (False, "Windows PowerShell answered 1")
+    assert ws.launch_background(ps=lambda s: (1, ""), which=lambda n: "/w", on_wsl=lambda: True, copy=lambda ps: False) == (False, "Windows PowerShell answered 1")
     assert ws.headless_args("UbuntuD", "u", ["/w"], ws.UI_QUIET) == "--headless wsl.exe -d UbuntuD -u u --cd ~ -- /w ui --no-browser --hidden"
+
+
+def test_a_hidden_start_carries_this_terminal_s_path():
+    """wsl.exe -- reads no ~/.bashrc: the hidden copy found no OpenCode (nvm's) and no witbitz-code (the owner, 2026-10-09)."""
+    from witbitz_code import wslstart as ws
+    path = "/home/u/.nvm/versions/node/v24.3.0/bin:/home/u/.local/bin:/usr/bin:/mnt/c/Program Files/Git/cmd:/mnt/c/WINDOWS/system32:/usr/bin::/x;rm"
+    assert ws.carried_path(path) == "/home/u/.nvm/versions/node/v24.3.0/bin:/home/u/.local/bin:/usr/bin:/mnt/c/WINDOWS/system32"
+    assert ws.wsl_command("/home/u/.local/bin/witbitz-code", path)[:2] == ["env", "PATH=" + ws.carried_path(path)]
+
+
+def test_the_shortcuts_carry_witbitz_icons_and_wsl_copies_its_own_to_windows(monkeypatch):
+    """The owner, 2026-10-09: the WSL entry "has a terminal icon" (conhost's)."""
+    import os
+    from witbitz_code import wslstart as ws
+    assert os.path.getsize(ws.icon_file("witbitz-code.ico")) > 1000 and os.path.getsize(ws.icon_file("witbitz-code-wsl.ico")) > 1000
+    s = ws.enable_script("x.lnk", "-a", icon=ws.WSL_ICON)
+    assert "if (Test-Path ((Join-Path (Join-Path $env:LOCALAPPDATA 'Witbitz-WSL') 'witbitz-code-wsl.ico')))" in s and "IconLocation" in s
+    assert "IconLocation" not in ws.enable_script("x.lnk", "-a"), "no icon asked → the script is as before (Node parity)"
+    seen = []
+    ws.launch_background(ps=lambda script: seen.append(script) or (0, "ok"), which=lambda n: "/w", on_wsl=lambda: True, copy=lambda ps: True)
+    assert "IconLocation" in seen[0] and "Witbitz-WSL" in seen[0]
+    seen.clear()
+    ws.launch_background(ps=lambda script: seen.append(script) or (0, "ok"), which=lambda n: "/w", on_wsl=lambda: True, copy=lambda ps: False)
+    assert "IconLocation" not in seen[0], "no icon copied → the shortcut keeps its own icon"
+
+
+def test_the_icon_is_written_into_windows_local_app_data_from_this_side(tmp_path):
+    from witbitz_code import wslstart as ws
+    win = tmp_path / "Local"
+    win.mkdir()
+    ok = ws.copy_icon(ps=lambda s: (0, "C:\\Users\\a\\AppData\\Local"), to_linux=lambda p: str(win) if p.endswith("Local") else "")
+    assert ok and (win / "Witbitz-WSL" / "witbitz-code-wsl.ico").read_bytes() == open(ws.icon_file("witbitz-code-wsl.ico"), "rb").read()
+    assert ws.copy_icon(ps=lambda s: (-1, ""), to_linux=lambda p: str(win)) is False
+    assert ws.copy_icon(ps=lambda s: (0, "ok"), to_linux=lambda p: "ok") is False, "not a Windows folder: never written"