scalix 1.4.1 → 1.5.1

package/CHANGELOG.md

@@ -2,6 +2,66 @@
 
 All notable changes to Scalix Coder will be documented in this file.
 
+## [1.5.1] - 2026-08-08
+
+### Added
+- **Scalix Cloud key for BYOK sessions.** The platform tools (deploy, database, storage, …) now run on their own credential pair, independent of inference: `SCALIX_CLOUD_API_KEY` / `SCALIX_CLOUD_BASE_URL` env, a keychain slot and settings row in the VS Code extension, and a wizard step in the CLI. Inference on your own endpoint, deploys still on Scalix — the BYOK key never reaches Scalix and the Scalix key never reaches your endpoint. The IPC engine now registers the cloud tools at startup; the GUI previously had none at all, and models asked to deploy invented SDKs and CLI flags instead.
+- **Guided setup.** Full-page setup panel in the extension (provider presets, key/model/limits, engine and terminal-CLI status with an install button) that auto-opens on first run and lands in chat after save; `/setup` slash command in both surfaces.
+- **The agent knows what is at its disposal.** While a cloud connection is live, every request carries a section listing the registered `scalix_*` tool groups and the platform's ~30s per-call execution ceiling, steering long operations to the async pairs (`scalix_build_create` → poll `scalix_build_status`) instead of one blocking call that the transport would kill.
+- **Scope-aware tool catalog.** The catalog is filtered client-side by the API key's scope families, so the model only sees tools its key can plausibly call; `/cloud status` reports "N of M available to this key" and says when the key's own project binding overrides a configured project id (the platform ignores the header for API keys — the key wins).
+- **Key-shape guidance.** Platform tools need a project-scoped key with the `database:query` scope; setup copy now says so everywhere a key is entered, and the two known rejections map to one-line remedies (400 = org-wide key, 403 = missing database scope) in the wizard, `/cloud status`, headless warnings and the extension banner.
+- `/status` marks the context window as *assumed* when neither the user nor the API supplied a spec for the active model, and points at the `/setup` context-window override — no invented numbers.
+
+### Changed
+- **Scalix product steering is gated on connection state.** Full platform guidance only while Scalix Cloud is connected; a single neutral pointer on the Scalix provider while disconnected; nothing Scalix-specific on pure BYOK sessions. Coder is a generic tool — the pitch arrives with the tools, not before.
+- Cloud tool-call budget cut from 120s to 45s: the platform transport ends a call at ~30–35s, so the extra 75s only ever waited on a dead call.
+- Request timeout raised to 300s to match the platform's own walls (env-overridable via `SCALIX_REQUEST_TIMEOUT_MS`).
+
+### Fixed
+- **Model switching, 24 audited fixes + 3 from dogfooding videos.** `setModel` preserves the failover chain and mutates in place (sub-agents saw stale model lists), and resets the breaker; fresh sends no longer round-robin the chain; BYOK model specs are registered on every switch surface, so no more `max_tokens`-less requests that OpenRouter 400s; the TUI `/model` no longer fires mid-stream via the `/mode` prefix collision and persists chain-preservingly to the global config (project overrides no longer laundered); `/settings` reports live-vs-next-launch truthfully; a `SCALIX_MODEL` override is announced; the IPC engine survives stray rejections — a 429 used to kill the whole session.
+- The system prompt forbids inventing `scalix` packages or CLI flags and explains the `scalix_*` tools, with pinned SDK names (`@scalix-world/sdk` on npm, `scalix-sdk` on PyPI) and exact model ids.
+
+### Fixed (VS Code extension)
+- Scalix keys are verified against `/v1/me` before storing — a rejected key gets a dialog with the reason instead of failing silently later. BYOK keys are never probed.
+- Model QuickPick accepts mouse clicks under Antigravity's event ordering; model/command updates broadcast to every chat surface (the editor tab used to go stale); the shared-config watcher ignores its own writes, so adopting a config no longer reverts a fresh model switch; the settings Models tab was rebuilt — stable refresh, live active badge, auto-reload on provider/endpoint/key change.
+- `vsce` packaging: the extension manifest carries the `repository` field CI packaging requires.
+
+## [1.5.0] - 2026-08-02
+
+### Added
+- **BYOK — bring your own key and models.** New provider layer (`src/providers/`): the agent now runs against any **OpenAI-compatible endpoint** (OpenAI, OpenRouter, Ollama, LM Studio, Together, vLLM, LiteLLM, ...) with your own key. Setup wizard gained a provider step (Scalix stays the zero-config default/recommended); env config via `SCALIX_PROVIDER=openai` + `OPENAI_BASE_URL` + `OPENAI_API_KEY`. Endpoint roots are accepted with or without `/v1`. No default third-party endpoint — BYOK is fully opt-in.
+- Provider-scoped behavior: BYOK endpoints stream every turn (native tool-call deltas), skip the Scalix-only `max_tokens` clamp, and never receive the Scalix `thinking_level` extension; Scalix Cloud platform tools are gated to the Scalix provider. Per-provider credential slots in the OS keychain; legacy `/v1`-suffixed Scalix bases keep working.
+- BYOK model discovery reads whichever context-window field the endpoint actually reports (`context_length`, `max_model_len`, `max_context_length`, `context_window`, top level or under `top_provider`). A model that reports none is left without one rather than inheriting a borrowed number, and the wizard pre-fills a conservative 128K instead of a 1M figure almost no third-party model can honour.
+- BYOK streams ask for `stream_options.include_usage`, so `/cost`, the status bar and the context meter carry real numbers instead of sitting on zero. Dropped for the session if the endpoint rejects the field.
+- **Real cost tracking** — non-streaming responses read the platform's `x-scalix-cost-cents` estimate into `usage.cost`; `/cost` shows it as "Est. cost" with a pointer to console billing. No client-side price tables, nothing fabricated.
+- 429/503 responses honor the server's `Retry-After` (capped at 60s) instead of blind exponential backoff, and the wait is now visible while it happens instead of the turn sitting silently on "Thinking...".
+- `/status` shows the active provider; provider selection round-trips through config validation (whitelisted).
+- A benchmark suite (`bench/`, repo only — not in the package): seven coding tasks graded by held-out verifiers that never exist in the workspace the agent sees, with protected paths and mutation-graded test writing. Runs against `bin/scalix.js`, the same entrypoint npm installs. `npm run bench` for the deterministic tier, `npm run bench:live` against a real model.
+
+### Fixed
+- **Responses no longer truncate mid-answer** — every request on the Scalix path sends an explicit `max_tokens`, and the ceiling is now 16,384 (matching the platform's own cap) rather than 4,000. Omitting the field lets the platform apply a much smaller default. The ceiling is per session: the client asks for 16,384 and falls back to 4,000 for the rest of the session if the endpoint rejects it, so older deployments keep working without configuration.
+- **Tool calling against the Scalix platform** — agentic turns are no longer forced non-streaming. The client asks `/v1/ai/models` what the deployment supports and streams tool calls only where `streaming_tool_calls` is advertised; anything older, or unreachable, falls back to the non-streaming path that returns tool calls intact.
+- The Scalix identity probe (`/v1/me`) is no longer sent on BYOK sessions. It was posting your provider key to a route that does not exist on OpenRouter/Ollama/vLLM and turning the resulting 404 into a "Scalix Cloud unavailable" warning on a session that never involved Scalix Cloud.
+- Keychain reads and writes time out instead of hanging. A macOS keychain prompt nobody can see used to block the setup wizard's final keypress for ~20s with no feedback. When the keychain refuses outright and a secret has to stay in `config.json`, the app now says so instead of failing silently.
+- Token and cost reporting: totals are derived when a server sends only prompt/completion halves; a resumed session no longer prints "12,000 (0 prompt + 0 completion)"; and a session that spent tokens but received no cost header says where the real figure lives instead of implying it was free.
+- Terminal rendering: headings no longer arrive with their literal `##` attached, and emphasis inside list items is styled rather than printed as raw asterisks. Tool results are summarised to a readable line instead of a raw JSON envelope that buried the output and truncated the exit code. The banner is dropped rather than sliced in short or narrow terminals.
+- `/help` and the `/` typeahead are generated from one catalog and can no longer disagree — `/update` was reachable but unlisted, while `/fork`, `/permissions`, `/resume` and `/skills` were listed but missing from `/help`.
+- The setup wizard no longer opens its model step showing "At least one model is required" before anything has been typed.
+- Replay files are written with owner-only permissions (0600), matching sessions/config.
+
+### Fixed (VS Code extension)
+- A tool that failed is shown as failed. Every tool reports failure the same way and the panel was marking them all with a success check, on live and replayed sessions alike.
+- A model spec entered in the panel now reaches the engine: it is written to the shared config and pushed into the running process, where previously it affected no request at all.
+- Responses can no longer be lost between the final stream delta and the end of a turn, which left an empty reply bubble on tool-heavy turns.
+- Deleting a session asks first; the connection indicator can no longer read green while the engine is down; the thinking indicator stops when a turn ends without text; and the send button announces what it actually does when it becomes an abort button.
+- Keyboard shortcut help is generated from the extension manifest, so it cannot drift from the real bindings. `Scalix Coder: Open` renamed to `Scalix Coder: Open Chat Panel`.
+
+### Changed
+- System prompt's Scalix Platform section corrected to real products and behavior: Scalix Run (via `scalix-cloud` CLI) for deploys, ScalixNova for databases, Scalix Sandboxes for code execution, exact `scalix-lumio-*` model ids, no "automatic model routing" claim, and an explicit provider-non-disclosure rule.
+- Legacy public model ids in saved configs (`scalix-lite`, `scalix-balanced`, `scalix-max`, `scalix-embed`, `scalix-world-ai`, `scalix-advanced`) are normalized to their current Lumio ids on load.
+- Chat completions now send `x-client-type: cli` (parity with the models/cloud endpoints).
+- IPC `ready` event includes the engine `version` so the VS Code extension can detect engine/extension drift.
+
 ## [1.4.0] - 2026-07-05
 
 ### Added

package/README.md

@@ -6,7 +6,7 @@ AI-powered coding agent for the terminal and [VS Code](https://marketplace.visua
 ![Node](https://img.shields.io/badge/node-%3E%3D18-green)
 ![License](https://img.shields.io/badge/license-EULA-orange)
 
-Scalix Coder is a full-featured AI coding assistant that runs in your terminal and in your editor — the extension is live on the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=scalix.scalix) and [Open VSX](https://open-vsx.org/extension/scalix/scalix) (Cursor/Windsurf/VSCodium). It connects to the Scalix API (or your own compatible endpoint) and gives AI direct access to your codebase through 31 built-in tools — file editing, shell execution, search, git, web access, browser automation, vision, voice input, and more.
+Scalix Coder is a full-featured AI coding assistant that runs in your terminal and in your editor — the extension is live on the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=scalix.scalix) and [Open VSX](https://open-vsx.org/extension/scalix/scalix) (Cursor/Windsurf/VSCodium). It connects to the Scalix API (or your own compatible endpoint) and gives AI direct access to your codebase through 40 built-in tools — file editing, shell execution, search, git, web access, browser automation, vision, voice input, and more.
 
 ## One agent for your whole cloud
 
@@ -16,15 +16,34 @@ With a Scalix account, the agent is more than a coder: on start it fetches your
 - `/cloud` shows your connection, plan, and available tools; `/cloud refresh` re-fetches the catalog
 - No account (or catalog unreachable)? The agent says so once and runs in **local-only mode** with the built-in tools — nothing is faked
 
+## Bring your own key (BYOK)
+
+Scalix is the zero-config default, but the agent also runs against **any OpenAI-compatible endpoint** with your own key — OpenAI, OpenRouter, Ollama, LM Studio, Together, vLLM, LiteLLM, and friends. Pick "OpenAI-compatible endpoint" in the setup wizard (`scalix` → provider step, or `/setup`), or configure via env:
+
+```bash
+export SCALIX_PROVIDER=openai
+export OPENAI_BASE_URL=http://localhost:11434   # with or without /v1
+export OPENAI_API_KEY=sk-...
+export SCALIX_MODEL=llama3
+scalix
+```
+
+Notes:
+- There is **no default third-party endpoint** — BYOK is fully opt-in and the endpoint URL is always yours.
+- Scalix Cloud platform tools (database, deploys, storage, ...) are Scalix-only and are skipped on BYOK providers.
+- On BYOK endpoints the agent streams every turn (tool calls included) and lets the server govern output limits; model context/output specs come from your `customModels` config when you want exact windows.
+- Credentials are stored per provider (OS keychain / 0600 config), never shared between providers.
+- Anthropic, Vertex, and Bedrock native adapters are specced follow-ups (see MULTI-PROVIDER-ADAPTER-SPEC.md).
+
 ## Features
 
 - **Terminal UI** — Rich React/Ink interface with magenta-themed prompt, scrollable chat, streaming responses, and keyboard shortcuts
 - **[VS Code Extension](https://marketplace.visualstudio.com/items?itemName=scalix.scalix)** — Sidebar chat panel with inline diffs, tab completion, inline chat (Cmd+I), codebase search, model picker, checkpoints, and session history
-- **31 Built-in Tools** — Shell, file read/write/edit, search (ripgrep), git, web fetch/search, directory tree, notebooks, browser automation, vision, voice input, sub-agents
+- **40 Built-in Tools** — Shell, file read/write/edit, search (ripgrep), git, web fetch/search, directory tree, notebooks, browser automation, vision, voice input, sub-agents, task board
 - **Security Sandbox** — Path traversal prevention, symlink detection, command blocklist, injection detection, SSRF protection
 - **4 Permission Modes** — `plan` (read-only) / `default` (ask) / `auto` (auto-approve) / `yolo` (full autonomy)
 - **Context Management** — Auto-compression, sliding window, per-model context limits
-- **Dynamic Model Registry** — Models fetched from your Scalix account with exact context windows
+- **Dynamic Model Registry** — Models fetched from your Scalix account; context windows applied when the platform supplies them (sensible defaults otherwise, or set exact limits per model in config)
 - **Session Persistence** — Save, load, and resume conversations
 - **Project Intelligence** — Auto-detects tech stack, conventions, git context
 - **Plugin System** — Custom tools via `.scalix/plugins/`
@@ -199,14 +218,14 @@ Config is stored in `~/.scalix-coder/config.json`.
 
 | Setting                | Default   | Description                                   |
 | ---------------------- | --------- | --------------------------------------------- |
-| `maxSteps`             | 200       | Tool-call rounds per request                  |
-| `maxMessages`          | 200       | History size                                  |
+| `maxSteps`             | 500       | Tool-call rounds per request                  |
+| `maxMessages`          | 500       | History size                                  |
 | `maxContextTokens`     | 1,000,000 | Context window (tokens)                       |
-| `compressionThreshold` | 0.75      | Auto-compress when context exceeds this ratio |
-| `maxToolResultTokens`  | 10,000    | Truncate tool results (tokens)                |
-| `commandTimeoutMs`     | 60,000    | Shell command timeout (ms)                    |
-| `bgCleanupMs`          | 300,000   | Background process auto-cleanup (5 min)       |
-| `readFileMaxSize`      | 10 MB     | Max file size for read operations             |
+| `compressionThreshold` | 0.80      | Auto-compress when context exceeds this ratio |
+| `maxToolResultTokens`  | 50,000    | Truncate tool results (tokens)                |
+| `commandTimeoutMs`     | 120,000   | Shell command timeout (ms)                    |
+| `bgCleanupMs`          | 600,000   | Background process auto-cleanup (10 min)      |
+| `readFileMaxSize`      | 50 MB     | Max file size for read operations             |
 
 ### Project Files
 

package/dist/agent-replay.js

@@ -110,7 +110,8 @@ export class AgentReplay {
     async save() {
         await fs.mkdir(REPLAYS_DIR, { recursive: true });
         const filePath = path.join(REPLAYS_DIR, `${this.session.id}.json`);
-        await fs.writeFile(filePath, JSON.stringify(this.session, null, 2), 'utf-8');
+        // Replay files carry conversation content — same owner-only mode as sessions.
+        await fs.writeFile(filePath, JSON.stringify(this.session, null, 2), { encoding: 'utf-8', mode: 0o600 });
         return filePath;
     }
     static async load(sessionId) {