0.9.2

Changed — Packaging (lean install)

• Lean default install. Heavy/compiled dependencies are moved out of the
  base install into opt-in extras so pip install velune-cli resolves fast and
  cleanly on every platform. Core dependencies dropped from ~38 to 21 with no
  heavy compiled wheels. New extras: [rag] (lancedb, pyarrow, qdrant-client),
  [parsing] (tree-sitter grammars), [telemetry] (opentelemetry), [git]
  (gitpython); [all] aggregates everything. Every gated feature degrades
  gracefully when its extra is absent (e.g. semantic search becomes a no-op
  while lexical search and chat keep working). (pyproject.toml)

Changed — Startup performance

• velune --version is now near-instant (~1.6s → ~0.04s). The console
  script entry point is velune.main:main, which fast-paths --version
  without importing the command graph or runtime. The Typer app is built
  lazily instead of at import time. (velune/main.py, velune/cli/app.py)
• velune <cmd> --help no longer bootstraps the runtime (~3.9s → ~1.6s):
  the root callback skips full-subsystem initialization when help is requested.
• Removed a redundant second Ollama reachability probe on REPL startup.

Fixed

• First run with no providers and a non-interactive stdin now prints the
  velune setup hint and exits cleanly instead of blocking on a confirmation
  prompt or entering an unusable REPL. (velune/cli/app.py)
• The llama-cpp-python adapter error message no longer references the removed
  [llamacpp] extra. (velune/providers/adapters/llamacpp.py)
• MANIFEST.in now references the correct docs/CHANGELOG.md path.

Added — Quality

• Test suite wired into CI. The pytest suite (350 tests) now runs in CI
  across {Linux, macOS, Windows} × {3.11, 3.13} and gates merges and releases;
  asyncio_mode = "auto" is configured under [tool.pytest.ini_options].
• README documents pipx install velune-cli, the python -m velune fallback,
  and the Windows PATH note for the "velune is not recognized" case.

Added — Providers

• Cohere provider adapter — native Chat API with preamble/history conversion,
  streaming, and command-r-plus / command-r model catalog.
  (velune/providers/adapters/cohere.py)
• DeepSeek provider adapter — OpenAI-compatible API at api.deepseek.com;
  supports DeepSeek-R1 and DeepSeek-Coder. (velune/providers/adapters/deepseek.py)
• Mistral provider adapter — La Plateforme REST API; Mistral Large, Codestral,
  and Mixtral models. (velune/providers/adapters/mistral.py)
• NVIDIA NIM provider adapter — OpenAI-compatible API at integrate.api.nvidia.com;
  hosts Llama, Mistral, and partner NIM models. (velune/providers/adapters/nvidia.py)

Added — Git Integration

• GitHub and GitLab REST clients — velune/integrations/github.py and
  gitlab.py implement push-branch, create-PR/MR, fetch-issue, and
  post-comment operations using each platform's REST API.
• /push REPL command — pushes the current branch to origin (with optional
  --force). (velune/cli/slash_dispatcher.py)
• /pr REPL command — creates a pull request (GitHub) or merge request
  (GitLab) for the current branch from inside the REPL.
• /issue <number> REPL command — fetches a GitHub/GitLab issue by number
  and injects the title, body, and labels as conversation context.
• /sandbox REPL command — shows the active sandbox type (subprocess or
  Docker) and its configuration status.

Added — Code Intelligence

• velune/analysis/ package — code intelligence tools running locally without
  an LLM call:
  • linter.py — runs ruff / pyflakes and surfaces structured diagnostics.
  • refactor.py — detects code smells (long functions, deep nesting, high
    complexity) and returns ranked findings.
  • type_inferrer.py — suggests type annotations for unannotated function
    signatures using AST analysis.
  • symbol_search.py — fast symbol and definition lookup across the indexed workspace.
• /lint [file] REPL command — lint a Python file and display Rich diagnostic output.
• /refactor <file> REPL command — detect code smells with severity rankings.
• /typify <file> REPL command — suggest type hints for unannotated functions.

Added — Declarative Plugin System

• velune/plugins/declarative/ package — Markdown-based plugin manifests:
  declarative agents (agent.py), slash commands (command.py), skills
  (skill.py), and a filesystem scanner (scanner.py).
• SKILL.md injection — plugins can ship a SKILL.md that is automatically
  appended to the council's system context when the plugin is active.
• /plugin REPL command — list, enable, disable, and reload declarative
  plugins without restarting the session.
• Lifecycle hook system (velune/hooks/) — a typed hook dispatcher and executor
  that fires pre_tool / post_tool events; plugins register handlers via
  their manifest.

Added — Background Service

• velune/daemon/ package — a background Velune service (server.py) with
  an IPC transport (transport.py) and a client (client.py).
• velune daemon start|stop|status CLI subcommands to manage the service.

Added — CLI Subcommands

• velune workspace subcommand group — init, status, graph, list,
  open, remove. workspace graph renders an interactive dependency tree
  from velune/observability/workspace_graph.py.
• velune session subcommand group — list, delete, export.
• velune provider subcommand group — add, remove, test, list, status.
• velune config subcommand group — get, set, show.
• velune usage, velune quota, velune health commands for
  analytics and provider monitoring.
• velune logs (alias for trace) — view or follow the execution event
  stream from the current workspace.
• velune status (alias for context) — show index freshness, file counts,
  and cognitive-core record counts without starting the full runtime.
• velune pipeline (alias for retrieval) — trace a retrieval query through
  the BM25 + vector + graph pipeline and show per-stage scores.
• velune memory subcommand group — inspect, clear, compact.

Added — REPL Commands

• /council <task> — force the full council tier regardless of task
  complexity classification.
• /new [title] — start a fresh conversation while keeping project memory.
• /project [name|path] — switch or manage project workspaces from within
  the REPL.
• /bench [run] — view stored benchmark results or trigger a new empirical
  capability run.
• /graph — render a hierarchical tree of knowledge graph entities for the
  current workspace.
• /hunk — toggle hunk-by-hunk review mode; each proposed file edit is
  shown and approved individually before being applied.
• /undo — revert the last Velune-generated git commit, leaving the changes
  staged for inspection.
• /approve [safe|ask|block] — set the tool/command approval gate for the
  session.
• /hooks — list all active lifecycle hooks and their configuration source.
• /stats — show session statistics: tokens used, estimated cost, turn
  count, and uptime.
• /history — show the REPL command execution history for the current session.
• /pull [model-id] and /delete <model-id> — download or delete
  Ollama models from within the REPL with live progress output.
• /mcp subcommands — servers, tools, resources, connect <name>,
  disconnect <name>, refresh <name> — inspect MCP connections without
  leaving the REPL.

Security

• Isolated llama-cpp-python from the default install set to eliminate the
  diskcache ≤ 5.6.3 transitive vulnerability (unsafe pickle deserialization — no
  patched version exists). The [gguf] optional extra now installs only the
  gguf metadata library, which is unaffected. In-process GGUF inference is
  available via the new [llamacpp] extra (pip install 'velune-cli[llamacpp]'),
  which is deliberately excluded from [all]. pip-audit now reports
  no known vulnerabilities on a default install. (pyproject.toml,
  velune/providers/adapters/llamacpp.py)

Added

• Intent reconstruction — new velune/cognition/intent.py with IntentClassifier
  and IntentType enum (EXPLAIN / GENERATE / REFACTOR / DEBUG / REVIEW / QUESTION / COMMAND).
  Zero-latency keyword + word-boundary scoring; wired into ContextOrchestrationEngine
  as Phase 0 on every prompt. (velune/cognition/intent.py)

• Council pipeline — CouncilRunner orchestrates the full planner → coder →
  reviewer → debate → synthesizer pipeline. Cycle exhaustion escalates REVISE to REJECT
  automatically. (velune/cognition/council_runner.py)

• DebateSession — scores and ranks council proposals using challenger severity and
  reviewer decision; produces structured audit reports for the synthesizer.
  (velune/cognition/council/debate.py)

• Multi-model role dispatch — ContextOrchestrationEngine.execute() routes requests
  through CouncilRunner when a CouncilAgentFactory is configured; degrades
  gracefully when no factory is present. (velune/orchestration/engine.py)

• WebSocket MCP transport — WebSocketConnection implements the MCPConnection
  contract over JSON-RPC 2.0 on ws:// and wss:// URLs, with SSRF URL validation,
  per-call timeout guards, and optional resource discovery.
  (velune/mcp/transports/websocket.py)

• /doctor council panel — new "Council" category in velune doctor output shows
  role assignment coverage (roles → model IDs) or warnings for unmapped roles.
  (velune/cli/commands/doctor.py)

• Async background tasks — long /run tasks no longer block the REPL prompt.

  • /run --bg <task> submits a task to the background and returns immediately.
  • The status bar shows ⚙ N bg while jobs are running.
  • New JobRegistry with JobRecord (ID, name, status, phase, elapsed, preview)
    and JobStatus enum (PENDING / RUNNING / COMPLETED / FAILED / CANCELLED).
    (velune/core/task_registry.py)

• /jobs command — list or cancel background jobs.

  • /jobs renders a live Rich table of all submitted jobs with color-coded status.
  • /jobs cancel <id> cancels a running job and clears its loop-detector state.

• /dashboard command — live progress dashboard.

  • Full-screen Rich Live layout: jobs table (top ⅔), alerts + provider health
    panels (bottom ⅓). Refreshes every 500 ms; press Enter or Ctrl+C to exit.
    (velune/cli/display/dashboard.py)

• Error self-healing with exponential backoff — the council orchestrator now
  automatically retries transient ProviderConnectionError, InferenceError, and
  TimeoutError failures up to config.providers.max_retries times (default 3),
  with randomized exponential backoff (min(base × 2^(attempt-1), 30s) × jitter).
  Each retry emits a retry.attempt event on the CognitiveBus.
  (velune/core/retry.py, velune/cognition/orchestrator.py)

• Error loop detection — sliding-window circuit breaker stops infinite retry
  cycles. ErrorLoopDetector fingerprints each exception (SHA-1 of type + message
  prefix) and trips after 3 occurrences within a 5-minute window, emitting a
  retry.loop_detected event and raising immediately rather than retrying.
  (velune/core/loop_detector.py)

• Proactive issue detection — ProactiveWatcher subscribes to CognitiveBus
  events and surfaces problems before the user asks.

  • job.failed → WARN alert
  • retry.loop_detected → DANGER alert
  • provider.health_changed (degraded/unavailable) → WARN/DANGER alert
  • context.threshold_crossed (70 % / 90 %) → WARN/DANGER alert
  • Periodic check (every 15 s) scans provider health manifests for UNAVAILABLE states.
  • Unread alerts drain after each REPL prompt and render as Rich panels above the
    input line. The status bar shows ⚠ N for pending alerts.
  • AlertStore (ring-buffer, max 20 entries) and ProactiveWatcher registered in
    the service container at startup / shutdown. (velune/proactive/)

• 52 new unit tests covering loop detection, retry policy, job registry,
  proactive watcher, and dashboard builders (all passing).

Refactored

• velune/cli/slash_dispatcher.py (new) — extracted _build_registry and
  _load_file_commands from VeluneREPL. repl.py reduced by ~440 lines
  (4,138 → 3,697).

• velune/cli/stream_renderer.py (new) — extracted streaming / non-streaming
  render loop from _handle_prompt into StreamRenderer.render() returning
  RenderResult(full_content, tokens_used, interrupted).

• Provider fallback — ProviderRouter.get_ordered_candidates() returns all viable
  candidates in capability-score order; BaseCouncilAgent iterates fallback providers
  on failure.

• Lineage search — MemoryLifecycleCoordinator.get_lineage_warnings() now
  delegates to LineageStore.query_continuity_warnings() instead of returning [].

• Diff parsing — CoderAgent._parse_diffs() replaced with parse_with_fallback()
  from velune/execution/edit_formats/registry.py.

• Plugins — deleted velune/plugins/schemas.py (legacy PluginManifest); updated
  PluginRegistry and PluginLoader to use DeclarativePluginManifest and an inline
  PluginManifest dataclass respectively. Deleted velune/context/window.py (legacy
  ContextWindowTracker); estimate_tokens() now lives in token_counter.py.

Changed

• StatusBarState gains bg_job_count and alert_count fields; render_status_bar
  renders them as warn-coloured segments only when non-zero. (velune/cli/statusbar.py)
• RuntimeBootstrapper.bootstrap() registers JobRegistry and AlertStore in the
  service container at startup. (velune/kernel/bootstrap.py)
• _async_main() now starts ProactiveWatcher after lifecycle.startup() and
  cleanly stops it in the finally block. (velune/kernel/entrypoint.py)

Fixed

• Intent classifier word boundaries — _score() now uses \b anchors so
  "build" no longer fires on "rebuild" and "implement" no longer fires on
  "implementation". Debug signals use substring matching to catch "KeyError" etc.

• velune/plugins/registry.py — register_plugin now calls
  _extract_hook_names() which handles both declarative (hooks JSON file) and legacy
  (inline hooks list) manifest shapes.

Tests

• tests/test_intent.py — 7 intent-type test classes + confidence + engine integration
  tests (28 cases total).
• tests/test_council_runner.py — happy path, revise-then-approve, reject-on-exhaustion,
  failure isolation, DebateSession unit tests, helper function tests (21 cases).
• Updated tests/test_mcp_phase2.py — test_unsupported_transport_raises replaced by
  test_returns_websocket_connection now that WebSocket is implemented.