revert: restore working tree to stable state at 51c6f86

Author: 1minds3t

.github/workflows/windows-concurrency-test.yml

@@ -49,6 +49,14 @@ jobs:
           python -m pip install --upgrade pip
           pip install -e .
 
+      - name: Configure omnipkg for non-interactive use
+        shell: pwsh
+        run: |
+          $configDir = "$HOME\.config\omnipkg"
+          New-Item -ItemType Directory -Force -Path $configDir | Out-Null
+          @{ interactive = $false; auto_confirm = $true } | ConvertTo-Json | Out-File -FilePath "$configDir\config.json" -Encoding utf8
+          Write-Host "✅ Omnipkg configured"
+
       - name: Run Demo (Option 8 - Quantum Multiverse)
         shell: cmd
         run: omnipkg demo 8 --non-interactive

src/omnipkg/dispatcher.c

@@ -978,22 +978,14 @@ static void fallback_to_python_v(const char *self_dir, char **argv,
 
     /* Try the config first */
     if (!read_self_config(self_dir, py, sizeof(py)) || !file_exists(py)) {
-        /* Try common names in self_dir, then parent (Scripts/ -> prefix/ on Windows). */
+        /* Try common names in self_dir */
         const char *names[] = {"python3.11","python3.10","python3.9",
-                               "python3","python","python.exe",NULL};
+                               "python3","python",NULL};
         int found = 0;
         for (int i = 0; names[i]; i++) {
             snprintf(py, sizeof(py), "%s/%s", self_dir, names[i]);
             if (file_exists(py)) { found = 1; break; }
         }
-        if (!found) {
-            char parent_dir[MAX_PATH];
-            dir_of(self_dir, parent_dir, sizeof(parent_dir));
-            for (int i = 0; names[i]; i++) {
-                snprintf(py, sizeof(py), "%s/%s", parent_dir, names[i]);
-                if (file_exists(py)) { found = 1; break; }
-            }
-        }
         if (!found) {
             fprintf(stderr, "omnipkg: cannot find host Python for fallback\n");
             exit(1);
@@ -1599,25 +1591,8 @@ int main(int argc, char **argv) {
     if (cli_version) {
         char venv_root[MAX_PATH];
         find_venv_root(self_real, venv_root, sizeof(venv_root));
-
-        /* Multi-candidate registry lookup: find_venv_root may miss on Windows
-         * (uses strrchr('/') only). Try venv_root, self_dir, self_dir parent. */
-        int reg_hit = 0;
-        if (venv_root[0])
-            reg_hit = registry_lookup(venv_root, cli_version,
-                                      target_python, sizeof(target_python));
-        if (!reg_hit)
-            reg_hit = registry_lookup(self_dir, cli_version,
-                                      target_python, sizeof(target_python));
-        if (!reg_hit) {
-            char parent_dir[MAX_PATH];
-            dir_of(self_dir, parent_dir, sizeof(parent_dir));
-            if (parent_dir[0])
-                reg_hit = registry_lookup(parent_dir, cli_version,
-                                          target_python, sizeof(target_python));
-        }
-
-        if (reg_hit) {
+        if (venv_root[0] && registry_lookup(venv_root, cli_version,
+                                            target_python, sizeof(target_python))) {
             if (!file_exists(target_python)) {
                 /* Not adopted yet → fallback to Python for auto-adopt */
                 if (debug) fprintf(stderr, "[C-DISPATCH] %s not found → auto-adopt fallback\n", target_python);
@@ -1627,30 +1602,28 @@ int main(int argc, char **argv) {
                 fprintf(stderr, "[C-DISPATCH] registry hit %s → %s\n",
                         cli_version, target_python);
         } else {
-            /* Registry miss — check if self-aware config python matches.
-             * Handle Windows where basename may be "python.exe". */
+            /* Registry miss — could be the native interpreter (not adopted, so not
+             * in registry.json).  Check if the self-aware config python matches the
+             * requested version before giving up and paying the Python fallback cost. */
             char self_py[MAX_PATH] = "";
             read_self_config(self_dir, self_py, sizeof(self_py));
             if (self_py[0] && file_exists(self_py)) {
-                /* Extract version from path. Try both / and \\ separators. */
+                /* Extract version from the path, e.g. ".../bin/python3.11" → "3.11" */
                 const char *base = strrchr(self_py, '/');
-                const char *base2 = strrchr(self_py, '\\');
-                if (base2 && (!base || base2 > base)) base = base2;
                 base = base ? base + 1 : self_py;
+                /* skip "python" prefix */
                 const char *ver_in_path = base;
                 if (strncmp(ver_in_path, "python", 6) == 0) ver_in_path += 6;
-                char ver_buf[32] = "";
-                strncpy(ver_buf, ver_in_path, sizeof(ver_buf) - 1);
-                char *dot_exe = strstr(ver_buf, ".exe");
-                if (dot_exe) *dot_exe = '\0';
-                if (strncmp(ver_buf, "3.", 2) == 0 &&
-                    strcmp(ver_buf, cli_version) == 0) {
+                if (strncmp(ver_in_path, "3.", 2) == 0 &&
+                    strcmp(ver_in_path, cli_version) == 0) {
+                    /* Native interpreter matches — use it directly, no fallback needed */
                     strncpy(target_python, self_py, sizeof(target_python) - 1);
                     target_python[sizeof(target_python) - 1] = '\0';
                     if (debug)
                         fprintf(stderr, "[C-DISPATCH] native match %s → %s\n",
                                 cli_version, target_python);
                 } else {
+                    /* Genuinely unknown version → Python fallback for auto-adopt */
                     if (debug) fprintf(stderr, "[C-DISPATCH] unknown version %s → fallback\n", cli_version);
                     fallback_to_python_v(self_dir, argv, cli_version);
                 }

src/tests/test_concurrent_install.py

@@ -192,16 +192,30 @@ def ensure_daemon_running(interpreter_paths: list) -> bool:
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
             )
-            # Poll until daemon answers or we time out.
-            # Do NOT bail on launcher rc — on Windows the launcher exits with
-            # rc=1 even when the daemon it spawned is still starting (detached).
-            # The only reliable signal is the socket answering.
+            # Poll until daemon answers, launcher exits with error, or we time out.
             _came_up = False
             for i in range(60):
                 time.sleep(0.5)
                 rc = proc.poll()
-                if rc is not None:
-                    safe_print(f"   ℹ️  Launcher exited rc={rc} — polling socket for daemon")
+                if rc is not None and rc != 0:
+                    # Launcher exited non-zero — bail immediately, don't burn
+                    # the remaining 30s pretending the daemon might appear.
+                    try:
+                        _out = proc.stdout.read().decode("utf-8", errors="replace").strip()
+                        _err = proc.stderr.read().decode("utf-8", errors="replace").strip()
+                    except Exception:
+                        _out = _err = ""
+                    safe_print(f"   ❌ Launcher exited rc={rc} — daemon start failed")
+                    if _out:
+                        for ln in _out.splitlines():
+                            safe_print(f"   [launcher stdout] {ln}")
+                    if _err:
+                        for ln in _err.splitlines():
+                            safe_print(f"   [launcher stderr] {ln}")
+                    dump_daemon_log("DAEMON LOG ON FAILURE", only_on_error=False)
+                    return False
+                if rc == 0 and i == 0:
+                    safe_print("   ℹ️  Launcher exited rc=0 — daemon detached")
                 status = client.status()
                 if status.get("success"):
                     _daemon_elapsed = (time.perf_counter() - _daemon_start) * 1000