sliceagent 0.1.1__tar.gz → 0.1.3__tar.gz

{sliceagent-0.1.1 → sliceagent-0.1.3}/CHANGELOG.md

@@ -5,6 +5,39 @@ this project aims for [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.3] — 2026-07-02
+
+The five-door provider lineup + a wizard that feels like one.
+
+### Added
+- **Providers**: OpenRouter (hundreds of models, one key — now the first door), OpenAI,
+  **Anthropic/Claude** (new — via Anthropic's OpenAI-compatible endpoint), DeepSeek, Moonshot/Kimi,
+  plus custom endpoints. All five ride the single adapter — zero new dependencies.
+- **OpenRouter quirks**: reasoning intent maps to OpenRouter's unified `reasoning` object (works
+  WITH tools — the raw `reasoning_effort` param never could); tool-calling requests pin routing to
+  hosts that honor every param (`require_parameters`) so nothing silently degrades; per-call
+  `usage.cost` is parsed into the cost meter.
+- `ANTHROPIC_API_KEY` / `DEEPSEEK_API_KEY` / `OPENROUTER_API_KEY` accepted as key fallbacks.
+
+### Changed
+- **Wizard UX**: API key shows `******` as you type (no more invisible field); provider and model
+  are arrow-key menus (↑/↓ + Enter, Esc cancels) with per-provider model suggestions +
+  "type another model id…". Scripted/CI runs keep the plain typed flow.
+
+## [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.

{sliceagent-0.1.1 → sliceagent-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sliceagent
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -145,11 +145,10 @@ Footprint is light (no torch). `pip install -e .` works for a clone too. Homebre
 ## Quickstart
 
 ```bash
-sliceagent init            # guided setup: provider, API key, model → ~/.sliceagent/config.toml (tests your key)
-sliceagent                 # start the agent
+sliceagent                 # that's it — first run walks you through setup (provider, API key, live-tested), then you're in
 ```
 
-`init` writes the config so the next run needs no env vars. Prefer env vars? Export **both** `LLM_API_KEY` and `AGENT_MODEL` (plus `LLM_BASE_URL` for non-OpenAI endpoints) and skip `init` — there is no default model; sliceagent never picks one for you. Discover every setting with `sliceagent config --list`.
+Setup happens once, in-process, and writes `~/.sliceagent/config.toml` (0600) so every later run just starts. Re-configure anytime with `sliceagent init` (add/switch providers). Prefer env vars? Export **both** `LLM_API_KEY` and `AGENT_MODEL` (plus `LLM_BASE_URL` for non-OpenAI endpoints) — there is no default model; sliceagent never picks one for you. Discover every setting with `sliceagent config --list`.
 
 → Full walkthrough in **[QUICKSTART.md](QUICKSTART.md)** · **[CONTRIBUTING.md](CONTRIBUTING.md)** · **[CHANGELOG.md](CHANGELOG.md)**
 

{sliceagent-0.1.1 → sliceagent-0.1.3}/QUICKSTART.md

@@ -15,12 +15,14 @@ installed by default; everything still works without it (plain stdout).
 ## 2. Set up your provider
 
 ```bash
-sliceagent init
+sliceagent
 ```
 
-`init` walks you through it: pick a provider (Moonshot/Kimi, OpenAI, DeepSeek, or a custom OpenAI-compatible
-endpoint), paste your API key (hidden), choose a model. It then **tests the key with one request** and writes
-`~/.sliceagent/config.toml` (mode `0600` — it holds your key). The next `sliceagent` just works.
+Nothing to memorize — the **first run walks you through setup automatically**: pick a provider
+(OpenRouter — hundreds of models with one key — or OpenAI, Anthropic/Claude, DeepSeek, Moonshot/Kimi, or a custom OpenAI-compatible endpoint), paste your API key (hidden),
+choose a model. It **tests the key with one request**, writes `~/.sliceagent/config.toml` (mode `0600` —
+it holds your key), and drops you straight into the session. Every later `sliceagent` just starts.
+(Re-configure anytime — add or switch providers — with `sliceagent init`.)
 
 Prefer environment variables? Skip `init` and export them instead:
 

{sliceagent-0.1.1 → sliceagent-0.1.3}/README.md

@@ -112,11 +112,10 @@ Footprint is light (no torch). `pip install -e .` works for a clone too. Homebre
 ## Quickstart
 
 ```bash
-sliceagent init            # guided setup: provider, API key, model → ~/.sliceagent/config.toml (tests your key)
-sliceagent                 # start the agent
+sliceagent                 # that's it — first run walks you through setup (provider, API key, live-tested), then you're in
 ```
 
-`init` writes the config so the next run needs no env vars. Prefer env vars? Export **both** `LLM_API_KEY` and `AGENT_MODEL` (plus `LLM_BASE_URL` for non-OpenAI endpoints) and skip `init` — there is no default model; sliceagent never picks one for you. Discover every setting with `sliceagent config --list`.
+Setup happens once, in-process, and writes `~/.sliceagent/config.toml` (0600) so every later run just starts. Re-configure anytime with `sliceagent init` (add/switch providers). Prefer env vars? Export **both** `LLM_API_KEY` and `AGENT_MODEL` (plus `LLM_BASE_URL` for non-OpenAI endpoints) — there is no default model; sliceagent never picks one for you. Discover every setting with `sliceagent config --list`.
 
 → Full walkthrough in **[QUICKSTART.md](QUICKSTART.md)** · **[CONTRIBUTING.md](CONTRIBUTING.md)** · **[CHANGELOG.md](CHANGELOG.md)**
 

{sliceagent-0.1.1 → sliceagent-0.1.3}/install.sh

@@ -96,9 +96,8 @@ cat <<'EOF'
 
   ✓ sliceagent installed.
 
-  Next:
-    sliceagent init     # guided setup: provider, API key, model (tests your key)
-    sliceagent          # start the agent
+  Next — just one command:
+    sliceagent          # first run walks you through setup (provider, API key), then you're chatting
 
   If 'sliceagent' isn't found, open a NEW terminal (PATH was just updated).
   Docs: https://github.com/TT-Wang/sliceagent

{sliceagent-0.1.1 → sliceagent-0.1.3}/src/sliceagent/__init__.py

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

{sliceagent-0.1.1 → sliceagent-0.1.3}/src/sliceagent/cli.py

@@ -171,7 +171,8 @@ def main() -> None:
 
     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"))
+                    or os.environ.get("ANTHROPIC_API_KEY") or os.environ.get("DEEPSEEK_API_KEY")
+                    or os.environ.get("OPENROUTER_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
@@ -831,7 +832,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.1 → sliceagent-0.1.3}/src/sliceagent/llm.py

@@ -81,6 +81,9 @@ def _usage_dict(raw) -> dict | None:
     }
     if cache_read:
         usage["cached_tokens"] = cache_read                              # legacy key (only when present)
+    _cost = getattr(raw, "cost", None)                                   # OpenRouter: authoritative $ per call
+    if isinstance(_cost, (int, float)) and _cost >= 0:
+        usage["cost_usd"] = float(_cost)
     return usage
 
 
@@ -189,7 +192,9 @@ class OpenAILLM:
         # export OPENAI_API_KEY) — the surface the user configures says "LLM", not a provider name.
         # Resolve the ENDPOINT first: the proxy choice below depends on which provider it is.
         kwargs: dict = {"api_key": api_key or os.environ.get("LLM_API_KEY")
-                        or os.environ.get("OPENAI_API_KEY") or os.environ.get("MOONSHOT_API_KEY")}
+                        or os.environ.get("OPENAI_API_KEY") or os.environ.get("ANTHROPIC_API_KEY")
+                        or os.environ.get("DEEPSEEK_API_KEY") or os.environ.get("OPENROUTER_API_KEY")
+                        or os.environ.get("MOONSHOT_API_KEY")}
         resolved_base = base_url or os.environ.get("LLM_BASE_URL") or os.environ.get("OPENAI_BASE_URL")
         if not resolved_base and os.environ.get("MOONSHOT_API_KEY") and not (
                 os.environ.get("LLM_API_KEY") or os.environ.get("OPENAI_API_KEY")):
@@ -466,6 +471,12 @@ class OpenAILLM:
         from .model_catalog import capability
         r = self.reasoning
         model, base = self.model.lower(), self._base_url.lower()
+        if "openrouter" in base:
+            # OpenRouter's UNIFIED reasoning object translates effort per upstream vendor (OpenAI
+            # reasoning_effort / Anthropic thinking budget / Gemini thinkingLevel) and — unlike raw
+            # reasoning_effort on chat/completions — works WITH tools. "full" stays provider-default.
+            effort = {"fast": "low", "high": "high", "max": "high"}.get(r)
+            return {"extra_body": {"reasoning": {"effort": effort}}} if effort else {}
         if "deepseek" in model or "deepseek" in base:
             return {"extra_body": {"thinking": {"type": "disabled"}}} if r == "fast" else {}
         if not capability(self.model, self._base_url).supports_reasoning_effort:
@@ -637,6 +648,12 @@ class OpenAILLM:
         self._merge_kwargs(kwargs, self._cache_routing_kwargs())  # session-stable cache routing (0 added tokens)
         self._merge_kwargs(kwargs, self._reasoning_kwargs())
         self._merge_kwargs(kwargs, self._cache_kwargs(messages))
+        if "openrouter" in self._base_url.lower() and tools:
+            # OpenRouter routes one model slug across MANY hosts; some serve quantizations with broken
+            # tool calling, and unsupported params are DROPPED silently by default. require_parameters
+            # pins routing to hosts that honor every param we sent — a silent degrade becomes a visible
+            # error instead (the exact failure class behind the old reasoning-effort ceiling).
+            self._merge_kwargs(kwargs, {"extra_body": {"provider": {"require_parameters": True}}})
         # Provider quirk (isolated here, llm-agnostic): some reasoning models (gpt-5.5) reject
         # reasoning_effort TOGETHER with function tools on /v1/chat/completions (400 — "use /v1/responses").
         # Once seen, drop reasoning_effort whenever tools are present so we degrade to default reasoning

{sliceagent-0.1.1 → sliceagent-0.1.3}/src/sliceagent/onboarding.py

@@ -13,14 +13,64 @@ import os
 from .envspec import GROUPS, REGISTRY, current_value
 
 # provider presets: key → (label, base_url, default_model). 'custom' prompts for the base_url.
+# The lineup: one AGGREGATOR door (OpenRouter — breadth, one key) + four first-party doors
+# (OpenAI, Anthropic, DeepSeek, Moonshot). Anthropic rides its OpenAI-compatible endpoint, so all
+# five share the single OpenAILLM adapter — no per-provider SDKs.
 PROVIDERS = {
-    "1": ("moonshot", "Moonshot (Kimi)", "https://api.moonshot.cn/v1", "kimi-k2.7-code"),
+    "1": ("openrouter", "OpenRouter (hundreds of models, one key)", "https://openrouter.ai/api/v1", "openai/gpt-5.5"),
     "2": ("openai", "OpenAI", "", "gpt-5.5"),
-    "3": ("deepseek", "DeepSeek", "https://api.deepseek.com/v1", "deepseek-chat"),
-    "4": ("custom", "Custom OpenAI-compatible endpoint", "", ""),
+    "3": ("anthropic", "Anthropic (Claude)", "https://api.anthropic.com/v1", "claude-sonnet-5"),
+    "4": ("deepseek", "DeepSeek", "https://api.deepseek.com/v1", "deepseek-chat"),
+    "5": ("moonshot", "Moonshot (Kimi)", "https://api.moonshot.cn/v1", "kimi-k2.7-code"),
+    "6": ("custom", "Custom OpenAI-compatible endpoint", "", ""),
+}
+
+# wizard model MENU per provider — suggestions for the arrow picker, NOT a cap: "type another…"
+# always accepts any model id (the catalog/pricing layers stay the capability source of truth).
+MODEL_SUGGESTIONS = {
+    "openrouter": ["openai/gpt-5.5", "anthropic/claude-sonnet-5", "deepseek/deepseek-chat",
+                   "moonshotai/kimi-k2.7"],
+    "openai": ["gpt-5.5", "gpt-5", "gpt-5-mini", "o3"],
+    "anthropic": ["claude-sonnet-5", "claude-opus-4-8", "claude-haiku-4-5"],
+    "deepseek": ["deepseek-chat", "deepseek-reasoner"],
+    "moonshot": ["kimi-k2.7-code", "kimi-k2-0905-preview"],
+    "custom": [],
 }
 
 
+def _tty() -> bool:
+    import sys
+    try:
+        return sys.stdin.isatty() and sys.stdout.isatty()
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _masked_input(prompt_text: str, fallback):
+    """API-key entry with VISIBLE feedback — asterisks per keystroke (prompt_toolkit is_password)
+    instead of getpass's fully-invisible field, which first-run users read as 'nothing is happening'.
+    Falls back to getpass when the TUI stack is absent or anything goes wrong."""
+    try:
+        from prompt_toolkit import prompt as _ptk_prompt
+        return _ptk_prompt(prompt_text, is_password=True)
+    except (ImportError, OSError, EOFError):
+        return fallback(prompt_text)
+
+
+def _pick(options: list, default: int = 0):
+    """Arrow-key selector for the wizard (reuses the TUI's _arrow_select: ↑/↓ or ←/→ + Enter).
+    Returns the index; raises KeyboardInterrupt on Esc (→ the wizard's normal 'cancelled' path);
+    returns None when a selector can't safely run so the caller falls back to typed input."""
+    try:
+        from .tui import _arrow_select
+    except ImportError:
+        return None
+    idx = _arrow_select(options, default=default)
+    if idx == -1:
+        raise KeyboardInterrupt
+    return idx
+
+
 def _version() -> str:
     try:
         from . import __version__
@@ -182,11 +232,24 @@ def run_init(*, inp=input, getpw=None, llm_factory=None, home=None) -> int:
         if ans in ("n", "no"):
             out("  Leaving the existing config unchanged. Run `sliceagent` to start."); return 0
 
-    out("\n  Choose a provider:")
-    for k, (_id, label, base, model) in PROVIDERS.items():
-        out(f"    {k}. {label}" + (f"  ({model})" if model else ""))
+    # arrow-key niceties only on a REAL interactive run with the default input hooks — injected
+    # inp/getpw (tests, scripted runs) keep the typed flow byte-for-byte.
+    fancy = inp is input and getpw is __import__("getpass").getpass and _tty()
+    keys = sorted(PROVIDERS)
     try:
-        choice = inp("  > ").strip() or "1"
+        out("\n  Choose a provider (↑/↓ + Enter):" if fancy else "\n  Choose a provider:")
+        idx = None
+        if fancy:
+            labels = [f"{PROVIDERS[k][1]}" + (f"  — {PROVIDERS[k][3]}" if PROVIDERS[k][3] else "")
+                      for k in keys]
+            idx = _pick(labels)                       # Esc → KeyboardInterrupt → 'cancelled' below
+        if idx is not None:
+            choice = keys[idx]
+        else:                                          # typed fallback (no tty / selector unavailable)
+            for k in keys:
+                _id, label, _base, model0 = PROVIDERS[k]
+                out(f"    {k}. {label}" + (f"  ({model0})" if model0 else ""))
+            choice = inp("  > ").strip() or "1"
         pid, label, base_url, model = PROVIDERS.get(choice, PROVIDERS["1"])
         if pid == "custom":
             base_url = inp("  Base URL (OpenAI-compatible, e.g. https://host/v1): ").strip()
@@ -198,10 +261,27 @@ def run_init(*, inp=input, getpw=None, llm_factory=None, home=None) -> int:
         existing = existing.get(pid) if isinstance(existing, dict) else None
         existing = existing if isinstance(existing, dict) else {}
         existing_key = existing.get("api_key") or ""
-        key_prompt = "  API key (hidden, Enter to keep existing): " if existing_key else "  API key (hidden): "
-        key = getpw(key_prompt).strip() or existing_key
-        model = (inp(f"  Model [{existing.get('model') or model or 'required'}]: ").strip()
-                 or existing.get("model") or model)
+        key_prompt = ("  API key (typed as ******, Enter to keep existing): " if existing_key
+                      else "  API key (typed as ******): ") if fancy else (
+                      "  API key (hidden, Enter to keep existing): " if existing_key
+                      else "  API key (hidden): ")
+        key = (_masked_input(key_prompt, getpw) if fancy else getpw(key_prompt)).strip() or existing_key
+        picked_model = None
+        if fancy:
+            cur = existing.get("model") or model
+            opts = [m for m in ([cur] if cur else []) + MODEL_SUGGESTIONS.get(pid, []) if m]
+            opts = list(dict.fromkeys(opts)) + ["type another model id…"]
+            out("  Model (↑/↓ + Enter):")
+            midx = _pick(opts)
+            if midx is not None:
+                picked_model = None if opts[midx].startswith("type another") else opts[midx]
+                if picked_model is None:
+                    picked_model = inp("  Model id: ").strip()
+        if picked_model:
+            model = picked_model
+        else:
+            model = (inp(f"  Model [{existing.get('model') or model or 'required'}]: ").strip()
+                     or existing.get("model") or model)
     except (EOFError, KeyboardInterrupt):
         out("\n  cancelled."); return 1
     if not key:

{sliceagent-0.1.1 → sliceagent-0.1.3}/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.1 → sliceagent-0.1.3}/tests/test_onboarding.py

@@ -134,7 +134,7 @@ class _OkLLM:
 def init_writes_a_valid_config_on_success():
     home = tempfile.mkdtemp(prefix="init-")
     rc = onboarding.run_init(
-        inp=_seq("1", ""),                 # provider=moonshot, model=default
+        inp=_seq("5", ""),                 # provider=moonshot (menu slot 5), model=default
         getpw=_seq("sk-test-key"),
         llm_factory=lambda model: _OkLLM(),
         home=home)
@@ -180,7 +180,7 @@ def init_offers_to_save_after_a_failed_key_test():
 def init_custom_provider_prompts_base_url():
     home = tempfile.mkdtemp(prefix="init-custom-")
     rc = onboarding.run_init(
-        inp=_seq("4", "https://my.host/v1", "my-model"),   # custom → base url → model
+        inp=_seq("6", "https://my.host/v1", "my-model"),   # custom → base url → model (menu: 6 = custom)
         getpw=_seq("k"),
         llm_factory=lambda model: _OkLLM(),
         home=home)
@@ -193,7 +193,7 @@ def init_custom_provider_prompts_base_url():
 @check
 def init_aborts_without_a_key():
     home = tempfile.mkdtemp(prefix="init-nokey-")
-    rc = onboarding.run_init(inp=_seq("1", ""), getpw=_seq(""), llm_factory=lambda m: _OkLLM(), home=home)
+    rc = onboarding.run_init(inp=_seq("5", ""), getpw=_seq(""), llm_factory=lambda m: _OkLLM(), home=home)
     assert rc == 1, "no key → abort"
     assert not os.path.exists(os.path.join(home, ".sliceagent", "config.toml"))
 
@@ -224,7 +224,7 @@ def write_config_is_atomic_and_cleans_up_on_failure():
 @check
 def init_merge_keeps_existing_providers():
     home = tempfile.mkdtemp(prefix="init-merge-")
-    onboarding.run_init(inp=_seq("1", ""), getpw=_seq("k-moon"), llm_factory=lambda m: _OkLLM(), home=home)
+    onboarding.run_init(inp=_seq("5", ""), getpw=_seq("k-moon"), llm_factory=lambda m: _OkLLM(), home=home)
     # 2nd init on the existing config: "Add/update? [Y/n]" → "" (yes) → provider 2 (openai) → model ""
     onboarding.run_init(inp=_seq("", "2", ""), getpw=_seq("k-oai"), llm_factory=lambda m: _OkLLM(), home=home)
     data = tomllib.load(open(os.path.join(home, ".sliceagent", "config.toml"), "rb"))
@@ -239,10 +239,10 @@ def reinit_blank_key_keeps_existing_key_for_the_same_provider():
     # prompt (no retype) must KEEP the saved key/model, not abort — the abort-on-blank behavior
     # (init_aborts_without_a_key) is only correct for a provider with no existing entry.
     home = tempfile.mkdtemp(prefix="init-reblank-")
-    onboarding.run_init(inp=_seq("1", ""), getpw=_seq("k-moon"), llm_factory=lambda m: _OkLLM(), home=home)
+    onboarding.run_init(inp=_seq("5", ""), getpw=_seq("k-moon"), llm_factory=lambda m: _OkLLM(), home=home)
     # 2nd init: "Add/update? [Y/n]" → "" (yes) → provider 1 (moonshot, already saved) → key "" (blank,
     # keep existing) → model "" (blank, keep existing)
-    rc = onboarding.run_init(inp=_seq("", "1", ""), getpw=_seq(""), llm_factory=lambda m: _OkLLM(), home=home)
+    rc = onboarding.run_init(inp=_seq("", "5", ""), getpw=_seq(""), llm_factory=lambda m: _OkLLM(), home=home)
     assert rc == 0, "blank key on an already-configured provider must NOT abort"
     data = tomllib.load(open(os.path.join(home, ".sliceagent", "config.toml"), "rb"))
     assert data["providers"]["moonshot"]["api_key"] == "k-moon", "the existing key must be kept, not wiped"
@@ -252,7 +252,7 @@ def reinit_blank_key_keeps_existing_key_for_the_same_provider():
 @check
 def config_use_switches_default_provider():
     home = tempfile.mkdtemp(prefix="cfg-use-")
-    onboarding.run_init(inp=_seq("1", ""), getpw=_seq("k1"), llm_factory=lambda m: _OkLLM(), home=home)
+    onboarding.run_init(inp=_seq("5", ""), getpw=_seq("k1"), llm_factory=lambda m: _OkLLM(), home=home)
     onboarding.run_init(inp=_seq("", "2", ""), getpw=_seq("k2"), llm_factory=lambda m: _OkLLM(), home=home)
     assert onboarding.run_config(["--use", "moonshot"], home=home) == 0
     data = tomllib.load(open(os.path.join(home, ".sliceagent", "config.toml"), "rb"))

sliceagent-0.1.3/tests/test_provider_lineup.py

@@ -0,0 +1,95 @@
+"""The five-door provider lineup (OpenRouter + OpenAI/Anthropic/DeepSeek/Moonshot + custom) and the
+OpenRouter/Anthropic adapter quirks. All offline — stub objects, no network, no pytest.
+Run: PYTHONPATH=src python tests/test_provider_lineup.py
+"""
+import os
+import sys
+from types import SimpleNamespace as NS
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from sliceagent.llm import OpenAILLM, _usage_dict           # noqa: E402
+from sliceagent.onboarding import MODEL_SUGGESTIONS, PROVIDERS  # noqa: E402
+
+CHECKS = []
+def check(fn):
+    CHECKS.append(fn)
+    return fn
+
+
+def _stub(model: str, base: str, reasoning: str = "full") -> OpenAILLM:
+    obj = OpenAILLM.__new__(OpenAILLM)   # bypass __init__ (no network)
+    obj.model = model
+    obj._base_url = base
+    obj.reasoning = reasoning
+    return obj
+
+
+@check
+def lineup_is_the_agreed_five_doors_plus_custom():
+    ids = [PROVIDERS[k][0] for k in sorted(PROVIDERS)]
+    assert ids == ["openrouter", "openai", "anthropic", "deepseek", "moonshot", "custom"], ids
+    for _pid, _label, base, model in PROVIDERS.values():
+        if _pid != "custom":
+            assert model, f"{_pid} preset needs a default model"
+    assert PROVIDERS["3"][2] == "https://api.anthropic.com/v1"      # Claude via the OpenAI-compat endpoint
+    assert all(PROVIDERS[k][0] in MODEL_SUGGESTIONS for k in PROVIDERS), "every preset needs a model menu"
+
+
+@check
+def openrouter_reasoning_maps_to_the_unified_object():
+    llm = _stub("anthropic/claude-sonnet-5", "https://openrouter.ai/api/v1", reasoning="fast")
+    assert llm._reasoning_kwargs() == {"extra_body": {"reasoning": {"effort": "low"}}}
+    llm.reasoning = "high"
+    assert llm._reasoning_kwargs() == {"extra_body": {"reasoning": {"effort": "high"}}}
+    llm.reasoning = "full"   # default → provider default, no param at all (never force spend)
+    assert llm._reasoning_kwargs() == {}
+
+
+@check
+def openrouter_never_sends_raw_reasoning_effort():
+    # the raw chat param is exactly what 400s/DROPS silently upstream — the unified object replaces it
+    llm = _stub("openai/gpt-5.5", "https://openrouter.ai/api/v1", reasoning="max")
+    kw = llm._reasoning_kwargs()
+    assert "reasoning_effort" not in kw and kw["extra_body"]["reasoning"]["effort"] == "high"
+
+
+@check
+def anthropic_direct_stays_on_provider_defaults():
+    # claude via api.anthropic.com: no reasoning_effort (capability=False), no prompt_cache_key routing
+    llm = _stub("claude-sonnet-5", "https://api.anthropic.com/v1", reasoning="high")
+    assert llm._reasoning_kwargs() == {}, "anthropic family must not receive reasoning_effort"
+    assert llm._cache_routing_kwargs() == {}, "OpenAI cache routing keys must not go to Anthropic"
+
+
+@check
+def usage_dict_parses_openrouter_cost():
+    raw = NS(prompt_tokens=100, completion_tokens=10, prompt_tokens_details=None,
+             cache_creation_input_tokens=0, cost=0.0042)
+    u = _usage_dict(raw)
+    assert u["cost_usd"] == 0.0042 and u["prompt_tokens"] == 100
+    raw_no_cost = NS(prompt_tokens=1, completion_tokens=1, prompt_tokens_details=None,
+                     cache_creation_input_tokens=0)
+    assert "cost_usd" not in _usage_dict(raw_no_cost), "absent cost must not fabricate a field"
+
+
+@check
+def openrouter_tools_requests_pin_param_honoring_hosts():
+    llm = _stub("openai/gpt-5.5", "https://openrouter.ai/api/v1", reasoning="fast")
+    kwargs = {"extra_body": {}}
+    llm._merge_kwargs(kwargs, llm._reasoning_kwargs())
+    llm._merge_kwargs(kwargs, {"extra_body": {"provider": {"require_parameters": True}}})
+    eb = kwargs["extra_body"]
+    assert eb["reasoning"]["effort"] == "low" and eb["provider"]["require_parameters"] is True, \
+        "both quirks must coexist in one extra_body (deep merge)"
+
+
+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.3/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)