sliceagent 0.1.0__tar.gz → 0.1.2__tar.gz

{sliceagent-0.1.0 → sliceagent-0.1.2}/CHANGELOG.md

@@ -5,6 +5,37 @@ this project aims for [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.2] — 2026-07-02
+
+Nothing may hang the user — three fixes from a live first-run reproduction.
+
+### Fixed
+- **Repo-map walk is hard-bounded** (`max_dirs` budget): the first slice build can no longer hang for
+  minutes when the workspace root is huge (a home directory mistaken for a project, a giant monorepo).
+  Output caps existed; now the walk itself is bounded — worst case ~1s, maps what it saw.
+- **The OS-account home never counts as a project root**, independent of `$HOME`: a stray
+  `package.json` in the real home no longer turns the entire home directory into a "project"
+  (the prior guard compared against `$HOME`, which containers/sandboxes/sudo can override).
+- **Ctrl-C during the slice build cancels the turn cleanly** (`· cancelled`) instead of crashing the
+  REPL with a traceback — the build phase ran before the turn's interrupt handling.
+
+## [0.1.1] — 2026-07-02
+
+First-run onboarding, hardened by a live stranger walkthrough.
+
+### Added
+- **Auto-onboarding** — a bare interactive `sliceagent` with nothing configured now drops straight
+  into the guided setup wizard (provider → key → model → live test), then continues into the session.
+  No more "go run `sliceagent init`" bounce. Piped/CI runs keep the print-and-exit gate.
+- **Installer handles everything** — `install.sh` now also installs ripgrep (brew when available,
+  else an isolated ~2 MB static binary; no sudo) and pins `uv tool install --python 3.12`, so the
+  curl path has zero prerequisites even when the default Python is 3.9/3.10 (conda base, Ubuntu 22.04).
+
+### Changed
+- README: the curl installer is the primary install path; PyPI/pip is the "you manage the Python"
+  alternative. (Project renamed memagent → sliceagent the same day, before 0.1.1: PyPI's
+  name-similarity check blocks "memagent".)
+
 ## [0.1.0] — 2026-07-02
 
 First public release.

{sliceagent-0.1.0 → sliceagent-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sliceagent
-Version: 0.1.0
+Version: 0.1.2
 Summary: A coding agent with a new context-engineering framework: bounded, deterministic, reconstructed context (slice architecture) — built for long-horizon work.
 Author: TT-Wang
 License-Expression: MIT
@@ -116,21 +116,31 @@ Early, but the **core bet is validated** — see the measured head-to-head bench
 
 ## Install
 
-Straight from PyPI (any one of):
+One command — Linux, macOS, WSL2:
 
 ```bash
-uv tool install "sliceagent[tui]"     # uv (recommended)
-pipx install "sliceagent[tui]"        # pipx
-pip install "sliceagent[tui]"         # plain pip
+curl -fsSL https://raw.githubusercontent.com/TT-Wang/sliceagent/main/install.sh | sh
 ```
 
-Or the one-command bootstrap (installs `uv` if needed, then sliceagent in an isolated tool env):
+**The installer handles everything**: `uv`, its own Python 3.12, ripgrep, and sliceagent — in an isolated tool env, no sudo, no prerequisites, no conflicts with any Python you already have (conda base at 3.10? Rosetta-Intel conda on an M-series Mac? Doesn't matter). Then:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/TT-Wang/sliceagent/main/install.sh | sh
+sliceagent          # first run drops you straight into guided setup, then start chatting
 ```
 
-Footprint is light (no torch). `pip install -e .` works for a clone too. `ripgrep` is recommended (code search degrades gracefully without it). Homebrew / Docker arrive in v0.2.
+<details>
+<summary><b>Alternative: install from PyPI yourself</b> (you manage the Python — needs ≥ 3.11)</summary>
+
+```bash
+uv tool install --python 3.12 "sliceagent[tui]"     # uv — fetches Python itself
+pipx install "sliceagent[tui]"                      # pipx
+pip install "sliceagent[tui]"                       # plain pip (use a venv)
+```
+
+If `pip` refuses with `Requires-Python >=3.11`: `conda create -n sliceagent python=3.12 -y && conda activate sliceagent`, then pip install. `ripgrep` is recommended (code search degrades gracefully without it).
+</details>
+
+Footprint is light (no torch). `pip install -e .` works for a clone too. Homebrew / Docker arrive in v0.2.
 
 ## Quickstart
 

{sliceagent-0.1.0 → sliceagent-0.1.2}/README.md

@@ -83,21 +83,31 @@ Early, but the **core bet is validated** — see the measured head-to-head bench
 
 ## Install
 
-Straight from PyPI (any one of):
+One command — Linux, macOS, WSL2:
 
 ```bash
-uv tool install "sliceagent[tui]"     # uv (recommended)
-pipx install "sliceagent[tui]"        # pipx
-pip install "sliceagent[tui]"         # plain pip
+curl -fsSL https://raw.githubusercontent.com/TT-Wang/sliceagent/main/install.sh | sh
 ```
 
-Or the one-command bootstrap (installs `uv` if needed, then sliceagent in an isolated tool env):
+**The installer handles everything**: `uv`, its own Python 3.12, ripgrep, and sliceagent — in an isolated tool env, no sudo, no prerequisites, no conflicts with any Python you already have (conda base at 3.10? Rosetta-Intel conda on an M-series Mac? Doesn't matter). Then:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/TT-Wang/sliceagent/main/install.sh | sh
+sliceagent          # first run drops you straight into guided setup, then start chatting
 ```
 
-Footprint is light (no torch). `pip install -e .` works for a clone too. `ripgrep` is recommended (code search degrades gracefully without it). Homebrew / Docker arrive in v0.2.
+<details>
+<summary><b>Alternative: install from PyPI yourself</b> (you manage the Python — needs ≥ 3.11)</summary>
+
+```bash
+uv tool install --python 3.12 "sliceagent[tui]"     # uv — fetches Python itself
+pipx install "sliceagent[tui]"                      # pipx
+pip install "sliceagent[tui]"                       # plain pip (use a venv)
+```
+
+If `pip` refuses with `Requires-Python >=3.11`: `conda create -n sliceagent python=3.12 -y && conda activate sliceagent`, then pip install. `ripgrep` is recommended (code search degrades gracefully without it).
+</details>
+
+Footprint is light (no torch). `pip install -e .` works for a clone too. Homebrew / Docker arrive in v0.2.
 
 ## Quickstart
 

{sliceagent-0.1.0 → sliceagent-0.1.2}/install.sh

@@ -44,16 +44,52 @@ if ! command -v uv >/dev/null 2>&1; then
 fi
 
 # 2. install (or upgrade) sliceagent as an isolated uv tool
+# --python 3.12: don't inherit whatever python happens to be on PATH (conda base = 3.10,
+# Ubuntu 22.04 = 3.10, macOS system = 3.9 — all below the >=3.11 floor). uv fetches a managed
+# CPython 3.12 automatically when none is installed, so the installer has zero prerequisites.
 info "Installing sliceagent …"
-uv tool install --force "$PKG"
+uv tool install --force --python 3.12 "$PKG"
 
 # 3. make sure uv's tool bin is on PATH for future shells
 uv tool update-shell >/dev/null 2>&1 || warn "Could not auto-update PATH — you may need to add uv's tool bin (see 'uv tool dir') to your PATH."
 
-# 4. soft prerequisite: ripgrep powers the code index (sliceagent still runs without it, just searches less well)
+# 4. ripgrep powers the code index — install it too (brew when available, else a ~2 MB static
+# binary from GitHub into uv's tool bin: no sudo, isolated, removable with the rest).
 if ! command -v rg >/dev/null 2>&1; then
-  warn "ripgrep (rg) not found — sliceagent works without it, but code search is much better with it."
-  warn "Install it:  brew install ripgrep  |  apt install ripgrep  |  https://github.com/BurntSushi/ripgrep"
+  info "Installing ripgrep (code search) …"
+  if command -v brew >/dev/null 2>&1; then
+    brew install ripgrep >/dev/null 2>&1 || true
+  fi
+fi
+if ! command -v rg >/dev/null 2>&1; then
+  RG_VER="14.1.1"
+  case "$(uname -s)-$(uname -m)" in
+    Darwin-arm64)              RG_TARGET="aarch64-apple-darwin" ;;
+    Darwin-x86_64)             RG_TARGET="x86_64-apple-darwin" ;;
+    Linux-x86_64)              RG_TARGET="x86_64-unknown-linux-musl" ;;
+    Linux-aarch64|Linux-arm64) RG_TARGET="aarch64-unknown-linux-gnu" ;;
+    *)                         RG_TARGET="" ;;
+  esac
+  BIN_DIR="$(uv tool dir --bin 2>/dev/null || true)"
+  [ -n "$BIN_DIR" ] || BIN_DIR="$HOME/.local/bin"
+  if [ -n "$RG_TARGET" ]; then
+    RG_TMP="$(mktemp -d)"
+    RG_URL="https://github.com/BurntSushi/ripgrep/releases/download/${RG_VER}/ripgrep-${RG_VER}-${RG_TARGET}.tar.gz"
+    if { command -v curl >/dev/null 2>&1 && curl -fsSL "$RG_URL" -o "$RG_TMP/rg.tgz"; } \
+       || { command -v wget >/dev/null 2>&1 && wget -qO "$RG_TMP/rg.tgz" "$RG_URL"; }; then
+      mkdir -p "$BIN_DIR" \
+        && tar -xzf "$RG_TMP/rg.tgz" -C "$RG_TMP" \
+        && mv "$RG_TMP/ripgrep-${RG_VER}-${RG_TARGET}/rg" "$BIN_DIR/rg" \
+        && chmod +x "$BIN_DIR/rg" \
+        && info "ripgrep installed to $BIN_DIR/rg" \
+        || warn "Could not unpack ripgrep — sliceagent still works, code search is just weaker without it."
+    else
+      warn "Could not download ripgrep — sliceagent still works, code search is just weaker without it."
+    fi
+    rm -rf "$RG_TMP"
+  else
+    warn "No prebuilt ripgrep for this platform — sliceagent works without it (weaker code search)."
+  fi
 fi
 
 cat <<'EOF'

{sliceagent-0.1.0 → sliceagent-0.1.2}/src/sliceagent/__init__.py

@@ -1,3 +1,3 @@
 """sliceagent — a memory-native coding agent (deterministic, bounded, reconstructed context)."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"

{sliceagent-0.1.0 → sliceagent-0.1.2}/src/sliceagent/cli.py

@@ -163,12 +163,32 @@ def main() -> None:
     # config-persisted key/endpoint (written by `sliceagent init`) populate the env BEFORE the gate, so a
     # configured user never has to export anything; ENV still wins for one-off overrides.
     from .config import load_config
+
+    def _env_from_config(c) -> None:
+        for _env, _val in (("LLM_API_KEY", c.api_key), ("LLM_BASE_URL", c.base_url)):
+            if not os.environ.get(_env) and _val:
+                os.environ[_env] = _val
+
+    def _key_present() -> bool:
+        return bool(os.environ.get("LLM_API_KEY") or os.environ.get("OPENAI_API_KEY")
+                    or os.environ.get("MOONSHOT_API_KEY"))
+
+    def _first_run_setup(reason: str) -> bool:
+        """First-run UX: a bare interactive `sliceagent` with nothing configured drops STRAIGHT into the
+        init wizard instead of bouncing the user to a separate command. Non-interactive (piped/CI) keeps
+        the print-and-exit gate — never prompt into a pipe. Returns True when the wizard completed."""
+        if not (sys.stdin.isatty() and sys.stdout.isatty()):
+            return False
+        print(f"  {reason} — starting guided setup.\n")
+        from .onboarding import run_init
+        return run_init() == 0
+
     cfg = load_config()
-    for _env, _val in (("LLM_API_KEY", cfg.api_key), ("LLM_BASE_URL", cfg.base_url)):
-        if not os.environ.get(_env) and _val:
-            os.environ[_env] = _val
-    if not (os.environ.get("LLM_API_KEY") or os.environ.get("OPENAI_API_KEY")
-            or os.environ.get("MOONSHOT_API_KEY")):
+    _env_from_config(cfg)
+    if not _key_present() and _first_run_setup("Welcome! No API key configured yet"):
+        cfg = load_config()          # the wizard just wrote ~/.sliceagent/config.toml — pick it up
+        _env_from_config(cfg)
+    if not _key_present():
         print("No API key found. Run `sliceagent init` for guided setup, or set LLM_API_KEY (e.g. in a .env file).")
         sys.exit(1)
     # validate enum env vars (warn + use default; never crash) — a typo'd AGENT_POLICY is now visible.
@@ -211,6 +231,10 @@ def main() -> None:
     policy = make_policy("letitgo" if CONFIRMS.get(canonical) else canonical)
     # model + reasoning resolution: explicit env wins, then the saved /model choice (prefs), then config.
     _model = os.environ.get("AGENT_MODEL") or _prefs.get("model") or cfg.model
+    if not _model and _first_run_setup("No model configured yet"):
+        cfg = load_config()          # wizard picks provider+model → re-resolve from the fresh config
+        _env_from_config(cfg)
+        _model = os.environ.get("AGENT_MODEL") or _prefs.get("model") or cfg.model
     if not _model:   # no built-in default — the user picks the model (parallels the API-key gate above)
         print("No model configured. Run `sliceagent init` to pick a provider + model, "
               "or set AGENT_MODEL to your model name.")
@@ -807,7 +831,13 @@ def main() -> None:
             _stats["topic"] = one_line(session.active().goal, 40) if session.active_id else ""
             record_user(session.active(), line)  # short-range continuity: the RECENT CONVERSATION tier
             _expand_mentions(line)               # @path → pin the file into OPEN FILES
-            build = make_build_slice(session, tools, retriever, memory, line, session.session_id)
+            try:
+                # slice-build phase happens BEFORE run_turn's own KeyboardInterrupt handling — a ctrl-c
+                # here (e.g. during the one-time repo-map build) must cancel the turn, not crash the REPL.
+                build = make_build_slice(session, tools, retriever, memory, line, session.session_id)
+            except KeyboardInterrupt:
+                print("\n  · cancelled")
+                continue
             if os.environ.get("AGENT_TIMING"):   # per-turn latency breakdown (build vs model) → find the hang
                 import time as _tt
                 _b = build

{sliceagent-0.1.0 → sliceagent-0.1.2}/src/sliceagent/sensory_cortex.py

@@ -94,6 +94,17 @@ def _home() -> Optional[Path]:
         return None
 
 
+def _os_home() -> Optional[Path]:
+    """The account's home from the OS user database — independent of the $HOME env var. Guards the
+    home-is-not-a-project rule even when $HOME is overridden (containers, sudo, test sandboxes):
+    without this, a stray package.json in the real home turns the whole home dir into a 'project'."""
+    try:
+        import pwd
+        return Path(pwd.getpwuid(os.getuid()).pw_dir).resolve()
+    except (ImportError, KeyError, OSError):   # pwd is POSIX-only; degrade to the env-based home
+        return None
+
+
 def _marker_root(cwd: Path) -> Optional[Path]:
     """Nearest ancestor (≤6 levels) that looks like a project root, or ``None``.
 
@@ -104,11 +115,11 @@ def _marker_root(cwd: Path) -> Optional[Path]:
         current = cwd.resolve()
     except (OSError, RuntimeError, ValueError):
         return None
-    home = _home()
+    homes = {h for h in (_home(), _os_home()) if h is not None}
     for depth, parent in enumerate([current, *current.parents]):
         if depth > 6:
             break
-        if parent == home:
+        if parent in homes:
             continue
         try:
             for marker in _PROJECT_MARKERS:
@@ -443,7 +454,8 @@ _CODE_SUFFIX = (".py", ".js", ".ts", ".jsx", ".tsx", ".go", ".rs", ".java", ".rb
                 ".exs", ".clj", ".r", ".jl", ".vue", ".sql")
 
 
-def repo_map(root: str, *, max_entries: int = 300, max_per_dir: int = 25, max_chars: int = 12000) -> str:
+def repo_map(root: str, *, max_entries: int = 300, max_per_dir: int = 25, max_chars: int = 12000,
+             max_dirs: int = 4000) -> str:
     """A compact, ignore-aware STRUCTURAL MAP of the project (SENSORY CORTEX — the derived-view tier-B
     resident view, memoized for the session, never a persisted store): directories with their files,
     pruned of VCS/venv/cache + asset/log noise, RANKED by source-density so the real code tree shows
@@ -456,8 +468,17 @@ def repo_map(root: str, *, max_entries: int = 300, max_per_dir: int = 25, max_ch
     if not root or not os.path.isdir(root):
         return ""
     rows: list[tuple[str, list[str], int, int]] = []  # (rel, files, total, code_count)
+    walked = 0
     try:
         for dirpath, dirnames, filenames in os.walk(root):  # symlinks not followed
+            # HARD WALK BUDGET — the invariant is that repo_map completes in bounded time on ANY root.
+            # max_entries/max_chars cap the OUTPUT but only after the walk; without this, a huge root
+            # (a home dir mistaken for a project, a giant monorepo) hangs the first slice build for
+            # minutes inside os.walk. Past the budget we map what we saw — bounded beats complete.
+            walked += 1
+            if walked > max_dirs:
+                dirnames[:] = []
+                break
             dirnames[:] = sorted(d for d in dirnames if not _is_ignored(d))
             files = sorted(f for f in filenames
                            if not _is_ignored(f) and not f.endswith(_MAP_SKIP_SUFFIX))

sliceagent-0.1.2/tests/test_cli_smoke.py

@@ -0,0 +1,159 @@
+"""End-to-end launch smoke test: `sliceagent` must reach the input prompt WITHOUT crashing.
+
+Regression guard for the cli.py banner `NameError: name 'policy_mode' is not defined` (the var was
+renamed to the resolved `_eff_mode`/`canonical` in the 3-modes change but the banner still referenced the
+old name). No prior test exercised `main()` end-to-end, so the crash shipped. Runs main() in a subprocess
+with a fake key + AGENT_TUI=off + EOF stdin, so it boots, prints the banner, and exits on EOF — no network.
+"""
+import os
+import subprocess
+import sys
+
+_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def _launch(extra=None):
+    import tempfile
+    env = dict(os.environ)
+    env.update({
+        "PYTHONPATH": os.path.join(_ROOT, "src"),
+        "HOME": tempfile.mkdtemp(prefix="smoke-home-"),   # hermetic: the dev machine's ~/.sliceagent
+                                                          # config must not leak in (CI has none either)
+        "AGENT_TUI": "off",                 # plain REPL — no prompt_toolkit app to drive
+        "LLM_API_KEY": "sk-dummy-smoke", "OPENAI_API_KEY": "sk-dummy-smoke",
+        "AGENT_MODEL": "dummy-model-smoke", # required since the no-default-model gate — without it the
+                                            # CLI exits at the gate before the banner this test asserts on
+        "AGENT_PROXY": "off",               # don't route through a local proxy that isn't there
+    })
+    env.update(extra or {})
+    return subprocess.run(
+        [sys.executable, "-c", "from sliceagent.cli import main; main()"],
+        cwd=_ROOT, env=env, stdin=subprocess.DEVNULL,
+        capture_output=True, text=True, timeout=120,
+    )
+
+
+def main_reaches_prompt_without_crashing():
+    r = _launch()
+    out = r.stdout + r.stderr
+    assert "Traceback" not in out and "NameError" not in out, out[-2000:]
+    assert "policy=" in out, "startup banner never rendered (the line that held the NameError):\n" + out[-1500:]
+    assert r.returncode == 0, f"nonzero exit {r.returncode}\n{out[-1500:]}"
+
+
+def _no_key_env():
+    """A truly blank first-run env: temp HOME, every key/model var stripped."""
+    import tempfile
+    env = {k: v for k, v in os.environ.items()
+           if k not in ("LLM_API_KEY", "OPENAI_API_KEY", "MOONSHOT_API_KEY", "DEEPSEEK_API_KEY",
+                        "AGENT_MODEL", "LLM_BASE_URL", "AGENT_PROVIDER")}
+    env.update({"PYTHONPATH": os.path.join(_ROOT, "src"),
+                "HOME": tempfile.mkdtemp(prefix="firstrun-home-"),
+                "AGENT_TUI": "off", "AGENT_PROXY": "off"})
+    return env
+
+
+def piped_no_key_run_keeps_the_gate_no_prompt():
+    """Non-interactive (stdin=pipe) + no key must print the gate and exit 1 — never start the wizard
+    (a prompt into a pipe would hang CI/scripts)."""
+    r = subprocess.run([sys.executable, "-c", "from sliceagent.cli import main; main()"],
+                       cwd=_ROOT, env=_no_key_env(), stdin=subprocess.DEVNULL,
+                       capture_output=True, text=True, timeout=60)
+    out = r.stdout + r.stderr
+    assert "No API key found" in out, out[-800:]
+    assert "guided setup.\n\n" not in out and "sliceagent setup" not in out, \
+        "wizard must not auto-start without a tty:\n" + out[-800:]
+    assert r.returncode == 1, f"expected gate exit 1, got {r.returncode}"
+
+
+def interactive_first_run_auto_starts_the_wizard():
+    """First-run UX: a bare interactive `sliceagent` (tty, nothing configured) drops straight into the
+    init wizard — proven on a REAL pty by the wizard header + provider menu appearing unprompted.
+    (The abort path is covered in-process below; macOS getpass on a detached pty is not reliably
+    drivable, and the wizard's own logic has an injectable seam for exactly that reason.)"""
+    import pty
+    import select
+    import signal
+    import time
+    try:
+        m, s = pty.openpty()
+    except OSError:
+        return   # no pty on this host — skip
+    p = subprocess.Popen([sys.executable, "-c", "from sliceagent.cli import main; main()"],
+                         cwd=_ROOT, env=_no_key_env(), stdin=s, stdout=s, stderr=s,
+                         start_new_session=True)
+    os.close(s)
+    buf = bytearray()
+    deadline = time.monotonic() + 30
+    while time.monotonic() < deadline and b"Choose a provider" not in buf:
+        r, _, _ = select.select([m], [], [], 0.2)
+        if r:
+            try:
+                buf.extend(os.read(m, 4096))
+            except OSError:
+                break
+        if p.poll() is not None:
+            break
+    try:
+        os.killpg(p.pid, signal.SIGKILL)   # wizard reached (or not) — tear the child down either way
+    except (ProcessLookupError, PermissionError):
+        pass
+    p.wait()
+    try:
+        os.close(m)
+    except OSError:
+        pass
+    out = buf.decode(errors="replace")
+    assert "starting guided setup" in out, "wizard did not auto-start on an interactive first run:\n" + out[-1200:]
+    assert "sliceagent setup" in out and "Choose a provider" in out, "wizard header/menu missing:\n" + out[-1200:]
+
+
+def aborted_wizard_falls_back_to_the_gate():
+    """If the auto-started wizard is aborted (returns nonzero), main() must fall back to the plain
+    gate message and exit 1 — never proceed keyless. In-process with the wizard mocked, tty faked."""
+    import contextlib
+    import io
+    import tempfile
+    from types import SimpleNamespace
+    from unittest import mock
+
+    from sliceagent import cli as cli_mod
+    from sliceagent import onboarding as ob
+
+    env_patch = {k: "" for k in ("LLM_API_KEY", "OPENAI_API_KEY", "MOONSHOT_API_KEY", "AGENT_MODEL")}
+    env_patch["HOME"] = tempfile.mkdtemp(prefix="firstrun-abort-")
+    out = io.StringIO()
+    # one fake object doubling as tty-stdin (isatty only) and capturing tty-stdout: redirect_stdout
+    # would swap in a StringIO whose isatty() is False and silently close the wizard path.
+    fake_tty = SimpleNamespace(isatty=lambda: True, write=out.write, flush=lambda: None)
+    called = {"n": 0}
+
+    def _fake_init():
+        called["n"] += 1
+        return 1                                   # user aborted the wizard
+
+    _ = contextlib  # (kept import shape stable)
+    with mock.patch.dict(os.environ, env_patch), \
+         mock.patch.object(ob, "run_init", _fake_init), \
+         mock.patch.object(sys, "argv", ["sliceagent"]), \
+         mock.patch.object(sys, "stdin", fake_tty), \
+         mock.patch.object(sys, "stdout", fake_tty):
+        try:
+            cli_mod.main()
+            raise AssertionError("main() must exit after an aborted wizard")
+        except SystemExit as e:
+            assert e.code == 1, f"expected exit 1, got {e.code}"
+    text = out.getvalue()
+    assert called["n"] == 1, "the wizard was never invoked"
+    assert "No API key found" in text, "aborted wizard must fall back to the gate message:\n" + text
+
+
+if __name__ == "__main__":
+    main_reaches_prompt_without_crashing()
+    print("PASS main_reaches_prompt_without_crashing")
+    piped_no_key_run_keeps_the_gate_no_prompt()
+    print("PASS piped_no_key_run_keeps_the_gate_no_prompt")
+    interactive_first_run_auto_starts_the_wizard()
+    print("PASS interactive_first_run_auto_starts_the_wizard")
+    aborted_wizard_falls_back_to_the_gate()
+    print("PASS aborted_wizard_falls_back_to_the_gate")

{sliceagent-0.1.0 → sliceagent-0.1.2}/tests/test_prompt_ab.py

@@ -9,6 +9,12 @@ ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, os.path.join(ROOT, "src"))
 sys.path.insert(0, os.path.join(ROOT, "evals"))
 
+# The prompt A/B harness lives in evals/, which is local-only dev tooling (not shipped in the public
+# repo) — skip cleanly where it's absent (e.g. CI on the public checkout), like the no-pty skips.
+if not os.path.isdir(os.path.join(ROOT, "evals", "prompt_ab")):
+    print("SKIP: evals/prompt_ab not present (local-only eval tooling)")
+    sys.exit(0)
+
 from prompt_ab import stats as S          # noqa: E402
 from prompt_ab import variants as V       # noqa: E402
 

sliceagent-0.1.2/tests/test_repo_map_bounded.py

@@ -0,0 +1,91 @@
+"""The repo-map walk must be BOUNDED — it can never hang the first slice build, no matter what the
+workspace root is (a huge monorepo, or a home dir that a stray package.json turned into a 'project').
+Found live: launching from /Users/<u> with HOME overridden made os.walk crawl the entire home dir for
+minutes; ctrl-c then killed the REPL with a traceback. Invariant: repo_map completes within its walk
+budget on ANY root, and the OS-account home never counts as a project root regardless of $HOME.
+Run: PYTHONPATH=src python tests/test_repo_map_bounded.py
+"""
+import os
+import pathlib
+import sys
+import time
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from sliceagent import sensory_cortex as sc  # noqa: E402
+
+CHECKS = []
+def check(fn):
+    CHECKS.append(fn)
+    return fn
+
+
+def _make_tree(root: pathlib.Path, n_dirs: int) -> None:
+    for i in range(n_dirs):
+        d = root / f"pkg{i:03d}"
+        d.mkdir(parents=True)
+        (d / "mod.py").write_text("x = 1\n")
+
+
+@check
+def walk_stops_at_the_dir_budget():
+    import tempfile
+    root = pathlib.Path(tempfile.mkdtemp())
+    _make_tree(root, 60)
+    out = sc.repo_map(str(root), max_dirs=10)
+    # bounded: only what the budget allowed got mapped (root dir itself may count as one visit)
+    mapped = [ln for ln in out.splitlines() if ln.strip()]
+    assert 0 < len(mapped) <= 10, f"expected ≤10 mapped dirs under a 10-dir budget, got {len(mapped)}"
+
+
+@check
+def bounded_walk_is_fast_even_on_a_big_tree():
+    import tempfile
+    root = pathlib.Path(tempfile.mkdtemp())
+    _make_tree(root, 300)
+    t0 = time.monotonic()
+    out = sc.repo_map(str(root), max_dirs=50)
+    dt = time.monotonic() - t0
+    assert out, "map must still be produced within the budget"
+    assert dt < 5.0, f"bounded walk took {dt:.1f}s — the budget is not bounding"
+
+
+@check
+def default_budget_maps_a_normal_project_fully():
+    import tempfile
+    root = pathlib.Path(tempfile.mkdtemp())
+    _make_tree(root, 20)
+    out = sc.repo_map(str(root))          # default max_dirs — far above a normal project
+    assert sum(1 for ln in out.splitlines() if "mod.py" in ln) == 20, "normal projects must be unaffected"
+
+
+@check
+def os_account_home_never_counts_as_a_project_even_with_home_overridden():
+    import tempfile
+    fake_os_home = pathlib.Path(tempfile.mkdtemp())          # stands in for pw_dir
+    (fake_os_home / "package.json").write_text("{}")          # the stray marker that caused the live bug
+    orig = sc._os_home
+    sc._os_home = lambda: fake_os_home.resolve()
+    try:
+        # $HOME points elsewhere (the live-repro condition), yet the OS home must still be skipped
+        assert sc._marker_root(fake_os_home) is None, \
+            "a marker in the OS-account home must not make the home a project"
+        # ...while a real project UNDER the home is still detected
+        proj = fake_os_home / "code" / "myproj"
+        proj.mkdir(parents=True)
+        (proj / "pyproject.toml").write_text("[project]\nname='x'\n")
+        got = sc._marker_root(proj)
+        assert got is not None and got.name == "myproj", f"real subproject must still resolve, got {got}"
+    finally:
+        sc._os_home = orig
+
+
+if __name__ == "__main__":
+    ok = 0
+    for fn in CHECKS:
+        try:
+            fn(); ok += 1; print(f"PASS {fn.__name__}")
+        except Exception as e:  # noqa: BLE001
+            print(f"FAIL {fn.__name__}: {type(e).__name__}: {e}")
+    print(f"\n{ok}/{len(CHECKS)} passed")
+    sys.exit(0 if ok == len(CHECKS) else 1)

sliceagent-0.1.0/tests/test_cli_smoke.py

@@ -1,41 +0,0 @@
-"""End-to-end launch smoke test: `sliceagent` must reach the input prompt WITHOUT crashing.
-
-Regression guard for the cli.py banner `NameError: name 'policy_mode' is not defined` (the var was
-renamed to the resolved `_eff_mode`/`canonical` in the 3-modes change but the banner still referenced the
-old name). No prior test exercised `main()` end-to-end, so the crash shipped. Runs main() in a subprocess
-with a fake key + AGENT_TUI=off + EOF stdin, so it boots, prints the banner, and exits on EOF — no network.
-"""
-import os
-import subprocess
-import sys
-
-_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-
-def _launch(extra=None):
-    env = dict(os.environ)
-    env.update({
-        "PYTHONPATH": os.path.join(_ROOT, "src"),
-        "AGENT_TUI": "off",                 # plain REPL — no prompt_toolkit app to drive
-        "LLM_API_KEY": "sk-dummy-smoke", "OPENAI_API_KEY": "sk-dummy-smoke",
-        "AGENT_PROXY": "off",               # don't route through a local proxy that isn't there
-    })
-    env.update(extra or {})
-    return subprocess.run(
-        [sys.executable, "-c", "from sliceagent.cli import main; main()"],
-        cwd=_ROOT, env=env, stdin=subprocess.DEVNULL,
-        capture_output=True, text=True, timeout=120,
-    )
-
-
-def main_reaches_prompt_without_crashing():
-    r = _launch()
-    out = r.stdout + r.stderr
-    assert "Traceback" not in out and "NameError" not in out, out[-2000:]
-    assert "policy=" in out, "startup banner never rendered (the line that held the NameError):\n" + out[-1500:]
-    assert r.returncode == 0, f"nonzero exit {r.returncode}\n{out[-1500:]}"
-
-
-if __name__ == "__main__":
-    main_reaches_prompt_without_crashing()
-    print("PASS main_reaches_prompt_without_crashing")