@phuetz/code-buddy 1.3.0 → 1.3.2

package/README.md

@@ -17,7 +17,7 @@
 <p align="center">
   <a href="https://github.com/phuetz/code-buddy/stargazers"><img src="https://img.shields.io/github/stars/phuetz/code-buddy?style=flat-square&logo=github&color=feca57&label=Star" alt="GitHub stars"/></a>
   <img src="https://img.shields.io/badge/Tests-27K%2B-00d26a?style=flat-square&logo=jest" alt="Tests"/>
-  <img src="https://img.shields.io/badge/v1.3.0-GA-blueviolet?style=flat-square" alt="Version 1.3.0 GA"/>
+  <img src="https://img.shields.io/badge/v1.3.1-GA-blueviolet?style=flat-square" alt="Version 1.3.1 GA"/>
 </p>
 
 <br/>
@@ -45,7 +45,7 @@ Watch a **local model reason on screen, then use real tools to do the work** —
 [Proof ✅](docs/proof.md) ·
 [Quick Start](#quick-start) ·
 [In action](#in-action) ·
-[Features](#features) ·
+[What it does](#what-code-buddy-does) ·
 [FAQ](docs/faq.md) ·
 [Docs](#documentation) ·
 [Contributing](#contributing)
@@ -279,26 +279,68 @@ The CLI guards this: on Node < 22, `buddy gui` prints a clear upgrade message in
 
 ---
 
-## Features
-
-| Category | Highlights | Docs |
-|:---------|:-----------|:-----|
-| **AI Providers** | 15 providers (Grok, Claude, GPT, Gemini, Ollama, LM Studio, AWS Bedrock, Azure, Groq, Together, Fireworks, OpenRouter, vLLM, Copilot, Mistral), circuit breaker, model pairs | [providers.md](docs/providers.md) |
-| **Tools** | ~110 tools with RAG selection, multi-strategy edit matching, Codex-style `apply_patch`, streaming, BM25 tool search, code-exec sandbox | [tools-reference.md](docs/tools-reference.md) |
-| **Commands** | 190+ slash commands & CLI subcommands (`/goal`, `/dev`, `/pr`, `/lint`, `/switch`, `/think`, `/batch`, …) | [commands.md](docs/commands.md) |
-| **Cowork Desktop** | Electron cockpit, embedded engine, backend health/start controls, model settings, permission rules, visual workflows, traces, artifacts, MCP/skills/plugins | [cowork.md](docs/cowork.md), [ARCHITECTURE.md](cowork/ARCHITECTURE.md) |
-| **Agents** | Multi-agent orchestration (5-tool API), 8 specialized agents, SWE agent, planning flow, A2A protocol, batch decomposition, agent teams | [agents.md](docs/agents.md) |
-| **Goal loops** | `/goal` + `/subgoal` Ralph loop — a judge model re-checks completion every turn and auto-continues until done (turn budget, pause/resume, fail-open); headless `buddy goal`, board goal-mode, peer-session goals | [fleet-guide.md](docs/fleet-guide.md) |
-| **Reasoning** | Tree-of-Thought + MCTS (4 depth levels), extended thinking, auto-escalation, `/think` | [reasoning.md](docs/reasoning.md) |
-| **Fleet & Autonomy** | Peer-to-peer hub (`peer.chat` / `peer.tool.invoke` / `peer_delegate`), A2A + ACP + MCP interop, 24/7 autonomous service (`buddy autonomy install`), event-driven daemon, free-first local→Tailscale→paid tiering | [fleet-guide.md](docs/fleet-guide.md) |
-| **Security** | Guardian Agent (AI risk scoring), OS/Docker/OpenShell sandbox, SSRF guard, secrets vault, write/exec policy, loop & omission detection, output sanitizer | [security.md](docs/security.md) |
-| **Context Engine** | Smart compression, tool-output masking, image pruning, transcript repair, pre-compaction flush, JIT context, importance-weighted window | [context-engine.md](docs/context-engine.md) |
-| **Channels** | 20+ messaging channels (Telegram, Discord, Slack, WhatsApp, Signal, Teams, Matrix, …), DM pairing, send policy | [channels.md](docs/channels.md) |
-| **Companion & Vision** | ChatGPT-backed identity, voice/TTS, proactive check-ins, self-evaluation, mission board; opt-in webcam + MediaPipe face/hand/pose percepts, local face enrollment | [commands.md](docs/commands.md) |
-| **Memory & Knowledge** | Persistent + semantic + decision + coding-style memory, cross-session ICM, knowledge-base injection, 40 bundled skills, runtime self-authored skills | [context-engine.md](docs/context-engine.md) |
-| **Infrastructure** | HTTP server (OpenAI-compatible), WebSocket gateway, daemon, cron, device nodes, canvas/A2UI, cloud deploy configs, MCP, plugins | [infrastructure.md](docs/infrastructure.md) |
-| **Configuration** | Env vars, TOML config with profiles, model-aware limits, per-agent params, i18n (6 locales), personas | [configuration.md](docs/configuration.md) |
-| **Git & Code Intel** | Auto-commit (Aider-style), `/pr`, merge-conflict resolver, LSP rename/refactor, bug finder (25+ patterns, 6 langs), OpenAPI generator, IDE extensions | [development.md](docs/development.md) |
+## What Code Buddy does
+
+Code Buddy is one engine — terminal, desktop, and HTTP — that an LLM drives to read code, edit files, run commands, search the web, open PRs, and plan complex work. Below is the whole surface, explained. Jump to any area:
+
+| Area | In one line | Deep dive |
+|:-----|:------------|:----------|
+| [Providers & login](#providers--login) | 15 LLM providers + ChatGPT/xAI login at **$0** flat-fee, auto-failover, ensembles | [providers.md](docs/providers.md) |
+| [The agentic loop](#the-agentic-loop) | autonomous tool-calling with a middleware pipeline + confirm-before-execute | [CLAUDE.md](CLAUDE.md) |
+| [~110 tools](#110-tools) | edit/shell/web/browser/docs/media, RAG-selected, 5-strategy edit matching | [tools-reference.md](docs/tools-reference.md) |
+| [Reasoning](#reasoning) | extended thinking + Tree-of-Thought / MCTS, `/think` | [reasoning.md](docs/reasoning.md) |
+| [Goal loops & autonomy](#goal-loops--autonomy) | Ralph loop + LLM judge, YOLO, a 24/7 daemon | [fleet-guide.md](docs/fleet-guide.md) |
+| [Multi-AI Fleet](#multi-ai-fleet) | peers call each other's models + read-only tools over WebSocket | [fleet-guide.md](docs/fleet-guide.md) |
+| [Self-improvement](#self-improvement) | authors + empirically gates its own tools/skills (opt-in) | [CLAUDE.md](CLAUDE.md) |
+| [Skills](#skills) | 40 bundled (Office/research/automation) + authored + imported, firewalled | [commands.md](docs/commands.md) |
+| [Memory & context](#memory--context) | compression, importance-weighted window, JIT project context | [context-engine.md](docs/context-engine.md) |
+| [Security & sandboxing](#security--sandboxing) | Guardian risk-scorer, permission modes, sandbox tiers, SSRF guard, secrets | [security.md](docs/security.md) |
+| [Server & infrastructure](#server--infrastructure) | OpenAI-compatible HTTP, WS gateway, daemon, cron | [infrastructure.md](docs/infrastructure.md) |
+| [Channels](#channels) | 20+ messaging platforms with DM-pairing access control | [channels.md](docs/channels.md) |
+| [Git & code intelligence](#git--code-intelligence) | auto-commit, `/pr`, LSP rename, bug finder, the Code Explorer graph | [development.md](docs/development.md) |
+| [Config & modes](#config--modes) | TOML profiles, permission/agent/security modes, model-aware limits | [configuration.md](docs/configuration.md) |
+
+### Providers & login
+Code Buddy talks to **15 LLM providers** through one OpenAI-compatible dispatcher (`src/codebuddy/client.ts`), picking exactly one strategy at startup: Grok, Claude, GPT, Gemini, Ollama, LM Studio, AWS Bedrock, Azure, Groq, Together, Fireworks, OpenRouter, vLLM, Copilot, Mistral. **`buddy login`** signs into a ChatGPT Plus/Pro subscription (routed via OpenAI's Codex Responses backend) and **`buddy login xai`** into SuperGrok — both **flat-fee, no API key, cost reported `$0.0000`** (no per-token metering). Multiple logins coexist: **`buddy llm`** lists them, **`buddy llm ensemble "<q>"`** asks them all and synthesizes one answer, and `CODEBUDDY_LLM_FAILOVER=1` auto-continues on the next active LLM when one errors (per-provider circuit breakers). `[model_pairs]` in TOML splits an *architect* and *editor* model. **Validated live (2026-06-23, real keys / local):** chat works on **Mistral, Ollama, Gemini, xAI/Grok, OpenRouter and DeepSeek**; agentic tool-use (real `create_file`/`bash` calls) is confirmed on **Mistral** and **Grok**. Ollama/Grok/ChatGPT are also reproduced in [`docs/proof.md`](docs/proof.md). Anthropic is wired but its key needs API credits to verify. Other listed providers share the same dispatcher but aren't individually load-tested here.
+
+### The agentic loop
+The core is a stateful multi-turn loop (`src/agent/execution/agent-executor.ts`, `runTurnLoop`): the LLM proposes tool calls, the executor validates + confirms + runs them, feeds results back, and loops until done or you stop. A **middleware pipeline** (`src/agent/middleware/`) adds turn/cost limits, reasoning injection, workflow guards, auto-repair, and quality gates in priority order. Before any risky action the **ConfirmationService** checks permission mode → declarative rules → session flags → the Guardian Agent, and fail-closed guards block catastrophic commands (`rm -rf /`, fork bombs, `drop database`). Run it interactively (`buddy`), one-shot (`buddy -p "<task>"`), or fully autonomous (`buddy --yolo`).
+
+### ~110 tools
+The agent has **~110 tools** — file edit, shell, web search (5-provider fallback), a real headless browser, PDF/Office, media/vision, code-exec, agent orchestration — and uses **RAG selection** to send only the relevant ones each turn (BM25 `tool_search` as fallback). Edits land even in refactored code via a **5-strategy cascade**: exact → flexible (trim/indent) → regex (tokenized) → fuzzy (Levenshtein 10%) → LCS (90%). It also speaks Codex-style **`apply_patch`**, and `code_exec` runs LLM-written JavaScript in a `vm` sandbox (no `process`/`require`, 30s). Extend it with MCP servers (auto-discovered from `.codebuddy/mcp.json`), plugins, or new tool classes.
+
+### Reasoning
+Two systems: **Extended Thinking** (provider budget tokens — off/minimal/low/medium/high/xhigh) and Code Buddy's own **Tree-of-Thought + MCTS** with four depths (shallow CoT → beam search → MCTS → exhaustive). A reasoning middleware auto-detects complex queries and injects guidance; `/think`, `/megathink`, and `/ultrathink` set the depth, and the `reason` tool streams its search. (MCTSr Q-value `Q(a) = 0.5·(min(R) + mean(R))`.)
+
+### Goal loops & autonomy
+A **goal loop** is autonomy with a referee: the agent acts, an LLM **judge** checks the goal after each turn, and it self-corrects until done or the turn budget runs out — no hand-written retry logic. Drive it with `/goal "<objective>"` + `/subgoal` (numbered criteria), or headless `buddy goal`. **`buddy --yolo`** grants 400 tool rounds under a `$100` cap with guardrails, and the **24/7 autonomous daemon** (`buddy autonomy install`) claims tasks from a shared queue and runs them free-first (local → Tailscale → paid).
+
+### Multi-AI Fleet
+Run several Code Buddy instances as **peers on a WebSocket mesh** that observe each other's events live and call each other's models + read-only tools: `peer.chat` (one-shot), `peer.chat-session.*` (multi-turn, persisted), and `peer.tool.invoke` (remote read-only tools, behind three security gates that fail closed). **`/fleet route "<prompt>"`** classifies a task, gathers peer capabilities, runs a privacy lint (SSN/IBAN/card detection), and recommends a delegation; `/fleet listen|send|status|history` manage the mesh. It interops over A2A + ACP + MCP.
+
+### Self-improvement
+An empirically-gated loop (`src/agent/self-improvement/`) that improves Code Buddy's *learned* layer — never its own `src/`. It can author its own **lessons**, **tools** (`register_tool`, sandboxed, namespaced `authored__*`), and **skills**, each passing a gate before it's kept: tools must pass **held-out** behavioral cases the proposer never sees (a tool that hardcodes the visible answers fails fresh inputs → rejected), and skills pass a prompt-injection **firewall**. It's **opt-in and off by default** (`CODEBUDDY_SELF_IMPROVE=true`); `buddy improve status|cycle|tools|skills` drive it.
+
+### Skills
+Skills are procedural guidance (Markdown + frontmatter + triggers) the agent discovers and injects by topic. **40 are bundled**, including ones that build real Office docs and run analysis in *visible* Python steps (preflight libs → write script → run → verify): `xlsx`/`docx`/`pptx`, `doc-ingest` (PDF/Office → Markdown), `data-charts` (pandas/matplotlib), `web-automate` (Playwright), `web-research` (cited briefs). The agent can also **author** its own skills and **import** external ones from Hermes / OpenClaw — every imported skill is scanned by a **firewall** that quarantines prompt-injection/exfiltration payloads (`buddy skills import|imported|list`).
+
+### Memory & context
+For long sessions, `ContextManagerV2` compresses with a sliding window + **importance-weighted scoring** (errors 0.95, decisions 0.90, code 0.70, chat 0.25 — high-value messages survive truncation), masks old tool output, prunes stale images, and repairs the transcript after compaction. **JIT context** loads nearby `CODEBUDDY.md`/`CONTEXT.md`/`AGENTS.md` files when a tool touches a path, and each turn injects `<lessons_context>` and `<todo_context>`. Durable facts persist to bounded project/user memory (`/memory recent|remember|recall`), security-scanned against injection/secret-exfiltration.
+
+### Security & sandboxing
+Layered, fail-closed safety: the **Guardian Agent** scores each operation 0–100 (auto-approve <80, prompt 80–90, deny ≥90; read-only tools skip the LLM call), **permission modes** (`plan`/`acceptEdits`/`dontAsk`/`bypassPermissions`), **sandbox tiers** (read-only / workspace-write / full-access via bubblewrap·landlock·seatbelt, with `.git`/`.ssh`/`.aws` always read-only), an **SSRF guard** (blocks private ranges + IPv4/IPv6 bypass vectors with a DNS check before every fetch), an AES-256-GCM **secrets vault** (`buddy secrets`), a **write policy** (`strict` forces `apply_patch`), and an **output sanitizer** that strips model-leakage tokens.
+
+### Server & infrastructure
+**`buddy server`** exposes an HTTP API (port 3000) including an **OpenAI-compatible `/api/chat/completions`**, plus a **WebSocket gateway** (3001) for desktop/mobile clients (device pairing, presence, Origin-hardened, JWT in production). A **daemon** runs 24/7 with auto-restart, a heartbeat checklist, daily session reset, and a cross-platform service installer (systemd/launchd/Task Scheduler). **Cron** scheduling (`buddy cron add`) supports no-LLM `--watchdog` monitors and `--pre-check` gates so an expensive LLM run only fires when something actually changed.
+
+### Channels
+Code Buddy runs on **20+ messaging platforms** — Telegram, Discord, Slack, WhatsApp, Signal, Matrix, IRC, Nostr, Mattermost, Nextcloud Talk, iMessage (real persistent transports with auto-reconnect) plus REST/webhook adapters (Teams, Google Chat, Feishu, LINE, ntfy, DingTalk, WeCom, …). **DM pairing** prevents unauthorized credit burn: an unknown user gets a 6-char code (15-min TTL) you approve via `buddy pairing approve`. (A few niche adapters — Twitch/Tlon/Gmail — are in-process stubs, and Feishu real-time *inbound* needs the Lark SDK installed.)
+
+### Git & code intelligence
+`buddy dev run` plans + implements + tests + **auto-commits** with a Conventional-Commit message; **`/pr`** opens a summarized PR; `lsp_rename`/`lsp_code_action` drive language servers for safe refactors; the **bug finder** flags 25+ patterns across 6 languages. For whole-repo understanding, the optional **[Code Explorer](https://github.com/phuetz/code-explorer)** (the `gitnexus` MCP server — a standalone Rust code-intelligence engine) pre-indexes the repo into a knowledge graph with 31 tools for impact/blast-radius, coupling, hotspots, and execution traces, answering structural questions with ~40× less context. Code Buddy also runs as an **ACP** agent (`buddy acp`) so editors like Zed can drive it natively.
+
+### Config & modes
+Configure via env vars, **TOML profiles** (`[profiles.<name>]`, `buddy --profile`), and per-project `.codebuddy/settings.json`. **Permission modes** gate approvals, **agent modes** (`plan`/`code`/`ask`/`architect`) restrict the tool surface, and **security modes** (`suggest`/`auto-edit`/`full-auto`) tune the approval flow. Per-model capabilities (context window, max output, patch format) live in `src/config/model-tools.ts`. The UI ships in **English and French (complete)**; `de`/`es`/`ja`/`zh` are registered locale scaffolds that currently fall back to English.
 
 ---
 

package/dist/agent/autonomous/agentic-coding-runner.d.ts

@@ -2,7 +2,7 @@ import { type AgenticCodingApprovalDecision, type AgenticCodingExecutionGate, ty
 import { type AgenticCodingCheckpoint } from './checkpoint-manager.js';
 import { normalizeGitPath, isPathAllowedByContract, resolveRepoPath } from './agentic-coding-paths.js';
 export { normalizeGitPath, isPathAllowedByContract, resolveRepoPath };
-import { type GitNexusContext, type WorldModelInvariants } from '../../tools/gitnexus-tool.js';
+import { type CodeExplorerContext, type WorldModelInvariants } from '../../tools/code-explorer-tool.js';
 import type { FleetDispatchProfile } from '../../fleet/dispatch-profile.js';
 import { persistRunArtifact, applyDeclaredEdits, previewDeclaredEdits, runVerificationCommands } from './agentic-coding-edits.js';
 export { persistRunArtifact, applyDeclaredEdits, previewDeclaredEdits, runVerificationCommands };
@@ -1648,7 +1648,7 @@ export interface AgenticCodingRunReport {
     verificationRequested: boolean;
     workflow: AgenticCodingWorkflowReport;
     workflowBuilderProposal?: AgenticCodingWorkflowBuilderProposalReport;
-    gitnexusEvidence?: GitNexusContext;
+    codeexplorerEvidence?: CodeExplorerContext;
     worldModelInvariants?: WorldModelInvariants | null;
 }
 export interface AgenticCodingObservabilityReport {

package/dist/agent/autonomous/agentic-coding-runner.js

@@ -12,7 +12,7 @@ import { normalizeGitPath, isPathAllowedByContract, resolveRepoPath, } from './a
 // Re-export the extracted path helpers for backward compatibility — they used
 // to be defined in this module and are imported from here elsewhere.
 export { normalizeGitPath, isPathAllowedByContract, resolveRepoPath };
-import { GitNexusTool } from '../../tools/gitnexus-tool.js';
+import { CodeExplorerTool } from '../../tools/code-explorer-tool.js';
 import { evaluateScope } from '../scope-awareness.js';
 import { getActiveRunStore, RunStore } from '../../observability/run-store.js';
 import { ConfirmationService } from '../../utils/confirmation-service.js';
@@ -2473,13 +2473,13 @@ export function buildAgenticCodingEditProposalProducerDispatch(report, artifacts
                         `Recommended tool call: ${fleet.invocation?.tool ?? 'none'} ${JSON.stringify(fleet.invocation?.args ?? {})}`,
                         ...fleet.safety.map((note) => `- ${note}`),
                     ] : []),
-                    ...(report.gitnexusEvidence ? [
+                    ...(report.codeexplorerEvidence ? [
                         '',
-                        '=== GitNexus Context & Insights ===',
-                        `Likely Files to Edit: ${JSON.stringify(report.gitnexusEvidence.likelyFiles)}`,
-                        `Dependent Symbols: ${JSON.stringify(report.gitnexusEvidence.dependentSymbols)}`,
-                        `Tests to Watch: ${JSON.stringify(report.gitnexusEvidence.testsToWatch)}`,
-                        `Notes: ${report.gitnexusEvidence.notes || 'None'}`
+                        '=== CodeExplorer Context & Insights ===',
+                        `Likely Files to Edit: ${JSON.stringify(report.codeexplorerEvidence.likelyFiles)}`,
+                        `Dependent Symbols: ${JSON.stringify(report.codeexplorerEvidence.dependentSymbols)}`,
+                        `Tests to Watch: ${JSON.stringify(report.codeexplorerEvidence.testsToWatch)}`,
+                        `Notes: ${report.codeexplorerEvidence.notes || 'None'}`
                     ] : []),
                     ...(report.worldModelInvariants ? [
                         '',
@@ -2847,7 +2847,7 @@ export function aggregateReports(reports, originalContract, options, status) {
     }
     const uniqueBlockedReasons = Array.from(new Set(blockedReasons));
     const uniqueValidationErrors = Array.from(new Set(validationErrors));
-    const gitnexusEvidence = reports.find(r => r.gitnexusEvidence)?.gitnexusEvidence;
+    const codeexplorerEvidence = reports.find(r => r.codeexplorerEvidence)?.codeexplorerEvidence;
     const worldModelInvariants = reports.find(r => r.worldModelInvariants)?.worldModelInvariants;
     const plan = buildExecutionPlan({
         approvalDecision: undefined,
@@ -2901,7 +2901,7 @@ export function aggregateReports(reports, originalContract, options, status) {
         verification,
         verificationRequested: Boolean(options.runVerification),
         workflow: buildWorkflowReport(plan),
-        gitnexusEvidence,
+        codeexplorerEvidence,
         worldModelInvariants,
     };
 }
@@ -2972,7 +2972,7 @@ export function buildFinalReport(checkpoint) {
         verification,
         verificationRequested: Boolean(options.runVerification),
         workflow: buildWorkflowReport(plan),
-        gitnexusEvidence: checkpoint.gitnexusEvidence,
+        codeexplorerEvidence: checkpoint.codeexplorerEvidence,
         worldModelInvariants: checkpoint.worldModelInvariants,
     };
 }
@@ -3173,24 +3173,24 @@ export async function runAgenticCodingCell(options) {
     const repo = contract?.repo ?? '';
     const rulesFiles = contract ? await collectRulesFiles(contract.repo) : [];
     const executionGate = contract ? assessAgenticCodingExecutionGate(contract) : undefined;
-    let gitnexusEvidence;
+    let codeexplorerEvidence;
     let worldModelInvariants = null;
-    if (checkpointToResume?.gitnexusEvidence) {
-        gitnexusEvidence = checkpointToResume.gitnexusEvidence;
+    if (checkpointToResume?.codeexplorerEvidence) {
+        codeexplorerEvidence = checkpointToResume.codeexplorerEvidence;
     }
     else if (contract) {
-        observability.stepStart('gitnexus-context', { task: contract.task });
-        const gitnexus = new GitNexusTool();
-        gitnexusEvidence = await gitnexus.ask(contract.task);
-        observability.stepEnd('gitnexus-context', { hasEvidence: Boolean(gitnexusEvidence) });
+        observability.stepStart('code-explorer-context', { task: contract.task });
+        const codeExplorer = new CodeExplorerTool();
+        codeexplorerEvidence = await codeExplorer.ask(contract.task);
+        observability.stepEnd('code-explorer-context', { hasEvidence: Boolean(codeexplorerEvidence) });
     }
     if (checkpointToResume?.worldModelInvariants !== undefined) {
         worldModelInvariants = checkpointToResume.worldModelInvariants;
     }
     else if (contract) {
         observability.stepStart('world-model-read', { repo: contract.repo });
-        const gitnexus = new GitNexusTool();
-        worldModelInvariants = await gitnexus.readWorldModel();
+        const codeExplorer = new CodeExplorerTool();
+        worldModelInvariants = await codeExplorer.readWorldModel();
         observability.stepEnd('world-model-read', { hasInvariants: Boolean(worldModelInvariants) });
     }
     let dirtyFiles = [];
@@ -3249,7 +3249,7 @@ export async function runAgenticCodingCell(options) {
             verificationRequested: Boolean(options.runVerification),
             workflow: buildWorkflowReport(plan),
             workflowBuilderProposal,
-            gitnexusEvidence,
+            codeexplorerEvidence,
             worldModelInvariants,
         });
     }
@@ -3277,7 +3277,7 @@ export async function runAgenticCodingCell(options) {
             contract: finalContract,
             step: 'initialized',
             timestamp: new Date().toISOString(),
-            gitnexusEvidence,
+            codeexplorerEvidence,
             worldModelInvariants,
         });
         observability.stepEnd('checkpoint-save', { checkpointStep: 'initialized', runId: options.runId });
@@ -3473,7 +3473,7 @@ export async function runAgenticCodingCell(options) {
                     edges: [],
                 },
                 workflowBuilderProposal,
-                gitnexusEvidence,
+                codeexplorerEvidence,
                 worldModelInvariants,
             };
             const tempArtifacts = deriveAgenticCodingProposalLoopArtifacts(options.editProposalFile || path.join(path.dirname(taskFile), 'proposal-loop.json'));
@@ -3611,7 +3611,7 @@ export async function runAgenticCodingCell(options) {
         verificationRequested: Boolean(options.runVerification),
         workflow: buildWorkflowReport(plan),
         workflowBuilderProposal,
-        gitnexusEvidence,
+        codeexplorerEvidence,
         worldModelInvariants,
     });
 }
@@ -5550,7 +5550,7 @@ export function buildAgenticCodingProposalLoopCoworkWorkspace(check, queue, step
         kind: 'agentic-coding-harness-contract',
         label: 'Harness / security and orchestration contract',
         mode: 'passive',
-        objective: 'Converge Cowork, Code Buddy, GitNexus, Fleet and workflow artifacts around explicit authority boundaries.',
+        objective: 'Converge Cowork, Code Buddy, CodeExplorer, Fleet and workflow artifacts around explicit authority boundaries.',
         safetyNotes: [
             'Harness data is display metadata only.',
             'It defines what each artifact means; it does not execute, approve, write memory, push or deploy.',

package/dist/agent/autonomous/checkpoint-manager.d.ts

@@ -1,6 +1,6 @@
 import { AgenticCodingTaskContract } from './agentic-coding-contract.js';
 import type { AgenticCodingRunOptions, AgenticCodingRunReport, AgenticCodingVerificationResult } from './agentic-coding-runner.js';
-import { GitNexusContext, WorldModelInvariants } from '../../tools/gitnexus-tool.js';
+import { CodeExplorerContext, WorldModelInvariants } from '../../tools/code-explorer-tool.js';
 export interface AgenticCodingCheckpoint {
     runId: string;
     options: AgenticCodingRunOptions;
@@ -12,7 +12,7 @@ export interface AgenticCodingCheckpoint {
     reports?: AgenticCodingRunReport[];
     timestamp: string;
     verification?: AgenticCodingVerificationResult[];
-    gitnexusEvidence?: GitNexusContext;
+    codeexplorerEvidence?: CodeExplorerContext;
     worldModelInvariants?: WorldModelInvariants | null;
 }
 export declare function getCheckpointPath(runId: string): string;

package/dist/agent/base-agent.d.ts

@@ -192,7 +192,7 @@ export declare abstract class BaseAgent extends EventEmitter implements Agent {
     getMCPClient(): MCPClient;
     protected initializeMCP(): void;
     /** Resolves once MCP server initialization has settled (or no-op if MCP was
-     * never started). Headless/one-shot callers await this so the gitnexus-style
+     * never started). Headless/one-shot callers await this so the code-explorer-style
      * MCP tools are registered before the first turn instead of racing init. */
     getMCPReady(): Promise<void>;
     getContextStats(): import("./facades/agent-context-facade.js").ContextStats;

package/dist/agent/base-agent.js

@@ -317,7 +317,7 @@ export class BaseAgent extends EventEmitter {
         this.infrastructureFacade.initializeMCP();
     }
     /** Resolves once MCP server initialization has settled (or no-op if MCP was
-     * never started). Headless/one-shot callers await this so the gitnexus-style
+     * never started). Headless/one-shot callers await this so the code-explorer-style
      * MCP tools are registered before the first turn instead of racing init. */
     getMCPReady() {
         return this.infrastructureFacade.getMCPReady();

package/dist/agent/hermes-tool-parity-local.js

@@ -1,4 +1,4 @@
-import { CORE_TOOLS, MORPH_EDIT_TOOL, isMorphEnabled, SEARCH_TOOLS, TODO_TOOLS, KANBAN_TOOLS, MESSAGING_TOOLS, YUANBAO_TOOLS, HOMEASSISTANT_TOOLS, MOA_TOOLS, SPOTIFY_TOOLS, X_SEARCH_TOOLS, FEISHU_TOOLS, CRON_TOOLS, WEB_TOOLS, ADVANCED_TOOLS, MULTIMODAL_TOOLS, COMPUTER_CONTROL_TOOLS, BROWSER_TOOLS, CANVAS_TOOLS, AGENT_TOOLS, FIRECRAWL_TOOLS, LSP_TOOLS, SECRETS_TOOLS, ADVISOR_TOOLS, ASK_USER_QUESTION_TOOLS, EXIT_PLAN_MODE_TOOLS, CODEBASE_REPLACE_TOOLS, SESSION_TOOLS, GITNEXUS_TOOLS, } from '../codebuddy/tool-definitions/index.js';
+import { CORE_TOOLS, MORPH_EDIT_TOOL, isMorphEnabled, SEARCH_TOOLS, TODO_TOOLS, KANBAN_TOOLS, MESSAGING_TOOLS, YUANBAO_TOOLS, HOMEASSISTANT_TOOLS, MOA_TOOLS, SPOTIFY_TOOLS, X_SEARCH_TOOLS, FEISHU_TOOLS, CRON_TOOLS, WEB_TOOLS, ADVANCED_TOOLS, MULTIMODAL_TOOLS, COMPUTER_CONTROL_TOOLS, BROWSER_TOOLS, CANVAS_TOOLS, AGENT_TOOLS, FIRECRAWL_TOOLS, LSP_TOOLS, SECRETS_TOOLS, ADVISOR_TOOLS, ASK_USER_QUESTION_TOOLS, EXIT_PLAN_MODE_TOOLS, CODEBASE_REPLACE_TOOLS, SESSION_TOOLS, CODE_EXPLORER_TOOLS, } from '../codebuddy/tool-definitions/index.js';
 import { FLEET_TOOLS } from '../codebuddy/fleet-tool-defs.js';
 import { buildHermesToolParityManifest, } from './hermes-tool-parity-manifest.js';
 export function collectOfflineBuiltinTools() {
@@ -32,7 +32,7 @@ export function collectOfflineBuiltinTools() {
         CODEBASE_REPLACE_TOOLS,
         SESSION_TOOLS,
         FLEET_TOOLS,
-        GITNEXUS_TOOLS,
+        CODE_EXPLORER_TOOLS,
     ];
     const byName = new Map();
     for (const tool of groups.flat()) {

package/dist/agent/tool-handler.js

@@ -16,7 +16,7 @@
  * Tool instances are lazy-loaded on first access for optimal startup time.
  */
 import { TextEditorTool, MorphEditorTool, ImageTool, BashTool, } from "../tools/index.js";
-import { getFormalToolRegistry, createTextEditorTools, createBashTools, createLsTools, createSearchTools, createWebTools, createTodoTools, createCronjobTools, createDockerTools, createKubernetesTools, createGitTools, createMiscTools, createBrowserTools, createProcessTools, createVisionTools, createScriptTools, createPlanTools, createKnowledgeTools, createRelationshipIntelligenceTools, createInternetScoutTools, createLeadScoutTools, createBrowserOperatorTools, createWindowsTools, createMemoryTools, createParallelTools, createAttentionTools, createSkillsInspectionTools, createLessonsTools, createUserModelTools, createAliasTools, createMultimodalTools, createAdvancedTools, createCanvasTools, createLspTools, createMergeConflictTools, createVulnScannerTools, createCodebaseReplaceTools, createAdvisorTools, createFleetTools, createAskUserQuestionTools, createExitPlanModeTools, createGuiTools, createSessionTools, createGitNexusTools, createScreenpipeTools, } from "../tools/registry/index.js";
+import { getFormalToolRegistry, createTextEditorTools, createBashTools, createLsTools, createSearchTools, createWebTools, createTodoTools, createCronjobTools, createDockerTools, createKubernetesTools, createGitTools, createMiscTools, createBrowserTools, createProcessTools, createVisionTools, createScriptTools, createPlanTools, createKnowledgeTools, createRelationshipIntelligenceTools, createInternetScoutTools, createLeadScoutTools, createBrowserOperatorTools, createWindowsTools, createMemoryTools, createParallelTools, createAttentionTools, createSkillsInspectionTools, createLessonsTools, createUserModelTools, createAliasTools, createMultimodalTools, createAdvancedTools, createCanvasTools, createLspTools, createMergeConflictTools, createVulnScannerTools, createCodebaseReplaceTools, createAdvisorTools, createFleetTools, createAskUserQuestionTools, createExitPlanModeTools, createGuiTools, createSessionTools, createCodeExplorerTools, createScreenpipeTools, } from "../tools/registry/index.js";
 import { createRegisterToolTool } from "../tools/register-tool-handler.js";
 import { getMCPManager } from "../codebuddy/tools.js";
 import { getErrorMessage } from "../errors/index.js";
@@ -238,7 +238,7 @@ export class ToolHandler {
             ...createExitPlanModeTools(),
             ...createGuiTools(),
             ...createSessionTools(),
-            ...createGitNexusTools(),
+            ...createCodeExplorerTools(),
             ...createScreenpipeTools(),
             // Self-improvement: the agent can author its own tools (opt-in only).
             ...(process.env.CODEBUDDY_SELF_IMPROVE === 'true' ? [createRegisterToolTool()] : []),

package/dist/codebuddy/providers/provider-chatgpt-responses.d.ts

@@ -124,6 +124,10 @@ export declare class ChatGptResponsesProvider implements Provider {
      */
     private lastTurnReasoningItems;
     private disableModelFallback;
+    /** The model this provider was constructed with (the user's configured
+     *  session model). Never mutated by per-call overrides or fallback, so it is
+     *  the safe remap target when a mis-routed / non-Codex model arrives. */
+    private readonly configuredModel;
     constructor(opts: ChatGptResponsesProviderOptions);
     setModel(model: string): void;
     chat(messages: CodeBuddyMessage[], tools?: CodeBuddyTool[], opts?: ChatOptions): Promise<CodeBuddyResponse>;

package/dist/codebuddy/providers/provider-chatgpt-responses.js

@@ -54,11 +54,7 @@ function pickFallbackModel(current) {
     return FALLBACK_MODELS[idx + 1] ?? null;
 }
 /** Models served only by the classic OpenAI API — the ChatGPT/Codex backend
- *  never exposes them. When one reaches this provider WITHOUT an explicit user
- *  choice (e.g. a secondary call inheriting the global `gpt-4o` config default
- *  instead of the active session model), remap proactively to the known-good
- *  Codex model. This skips a guaranteed-failed round-trip and the noisy
- *  user-facing warning. (smoke-test finding F7, 2026-05-29) */
+ *  never exposes them. (smoke-test finding F7, 2026-05-29) */
 const CODEX_UNSUPPORTED_MODELS = new Set([
     'gpt-4o',
     'gpt-4o-mini',
@@ -66,13 +62,33 @@ const CODEX_UNSUPPORTED_MODELS = new Set([
     'gpt-4',
     'gpt-3.5-turbo',
 ]);
-function resolveCodexModel(model, hasExplicitModel) {
-    if (!hasExplicitModel && CODEX_UNSUPPORTED_MODELS.has(model)) {
-        const remapped = FALLBACK_MODELS[0] ?? 'gpt-5.2';
-        logger.debug(`[chatgpt-responses] "${model}" is not served by the Codex backend; using "${remapped}". Set --model to override.`);
-        return remapped;
-    }
-    return model;
+/** True when the ChatGPT/Codex backend can actually serve `model`: the gpt-5
+ *  family, the o-series reasoning models, and codex-suffixed slugs. Classic
+ *  gpt-4* (CODEX_UNSUPPORTED_MODELS) and other vendors' models (grok-*,
+ *  claude-*, gemini-*, …) are NOT served and would 400. */
+function isCodexServableModel(model) {
+    if (CODEX_UNSUPPORTED_MODELS.has(model))
+        return false;
+    if (FALLBACK_MODELS.includes(model))
+        return true;
+    return /^gpt-5/i.test(model) || /^o[1-9]/i.test(model) || /codex/i.test(model);
+}
+/** When a model the Codex backend cannot serve reaches this provider WITHOUT an
+ *  explicit `--model`, remap proactively — preferring the user's configured
+ *  session model — instead of firing a guaranteed-failed round-trip (and a
+ *  confusing fallback to yet another unsupported slug). Two real mis-routes hit
+ *  this: a secondary call inheriting a classic `gpt-4o` default (F7), and the
+ *  agent's task-router handing back a `grok-*` coding model on a ChatGPT session
+ *  (which otherwise 400s, then falls back to gpt-5.2 and 400s again → crash).
+ *  An explicit `--model` is always respected. (cross-vendor fix, 2026-06-21) */
+function resolveCodexModel(model, hasExplicitModel, configuredModel) {
+    if (hasExplicitModel || isCodexServableModel(model))
+        return model;
+    const target = configuredModel && isCodexServableModel(configuredModel)
+        ? configuredModel
+        : (FALLBACK_MODELS[0] ?? 'gpt-5.2');
+    logger.debug(`[chatgpt-responses] "${model}" is not served by the Codex backend; using "${target}". Set --model to override.`);
+    return target;
 }
 // ─────────────────────────────────────────────────────────────────────
 // Provider implementation
@@ -96,10 +112,15 @@ export class ChatGptResponsesProvider {
      */
     lastTurnReasoningItems = [];
     disableModelFallback;
+    /** The model this provider was constructed with (the user's configured
+     *  session model). Never mutated by per-call overrides or fallback, so it is
+     *  the safe remap target when a mis-routed / non-Codex model arrives. */
+    configuredModel;
     constructor(opts) {
         this.authProvider = opts.authProvider;
         this.refreshAuth = opts.refreshAuth ?? opts.authProvider;
         this.currentModel = opts.model;
+        this.configuredModel = opts.model;
         this.promptCacheKey = `cb-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
         this.disableModelFallback = opts.disableModelFallback ?? false;
     }
@@ -148,7 +169,7 @@ export class ChatGptResponsesProvider {
         };
     }
     async *chatStream(messages, tools = [], opts = {}) {
-        const model = resolveCodexModel(opts.model ?? this.currentModel, opts.model != null);
+        const model = resolveCodexModel(opts.model ?? this.currentModel, opts.model != null, this.configuredModel);
         // If this is a brand-new conversational turn (last user message has
         // no preceding tool round in messages), drop any stale reasoning
         // blobs from the previous turn — they belonged to a different

package/dist/codebuddy/providers/provider-openai-compat.js

@@ -317,6 +317,14 @@ export class OpenAICompatProvider {
         if (this.isLocalInference()) {
             return false;
         }
+        // `search_parameters` is an xAI/Grok-specific field. Sending it to other
+        // OpenAI-compatible providers (Mistral, Groq, Together, Fireworks, …)
+        // is rejected with HTTP 422. When search is off (the default) there is
+        // nothing to send anyway, so omit the field — a plain request must never
+        // carry a disabled-search config that breaks the upstream.
+        if (!searchParams.mode || searchParams.mode === 'off') {
+            return false;
+        }
         if (this.isXaiProvider()) {
             logger.debug('Skipping deprecated search_parameters for xAI provider', {
                 source: 'OpenAICompatProvider',

package/dist/codebuddy/tool-definitions/code-explorer-tools.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CodeExplorer Tool Definitions
+ *
+ * OpenAI function calling schema for the CodeExplorer tool.
+ */
+import type { CodeBuddyTool } from './types.js';
+export declare const CODE_EXPLORER_ASK_TOOL: CodeBuddyTool;
+export declare const CODE_EXPLORER_TOOLS: CodeBuddyTool[];

package/dist/codebuddy/tool-definitions/code-explorer-tools.js

@@ -0,0 +1,24 @@
+/**
+ * CodeExplorer Tool Definitions
+ *
+ * OpenAI function calling schema for the CodeExplorer tool.
+ */
+export const CODE_EXPLORER_ASK_TOOL = {
+    type: 'function',
+    function: {
+        name: 'code_explorer_ask',
+        description: 'Consult CodeExplorer for a query or code understanding request. Returns related files, dependent symbols, tests to watch, and technical recommendations. This is a read-only tool.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The query or task description to ask CodeExplorer about.',
+                },
+            },
+            required: ['query'],
+        },
+    },
+};
+export const CODE_EXPLORER_TOOLS = [CODE_EXPLORER_ASK_TOOL];
+//# sourceMappingURL=code-explorer-tools.js.map

package/dist/codebuddy/tool-definitions/graph-tools.d.ts

@@ -1,5 +1,5 @@
 /**
- * Graph Tool Definitions — GitNexus Knowledge Graph
+ * Graph Tool Definitions — CodeExplorer Knowledge Graph
  *
  * OpenAI function calling schemas for:
  * - analyze_impact: Blast radius analysis for symbol changes

package/dist/codebuddy/tool-definitions/graph-tools.js

@@ -1,5 +1,5 @@
 /**
- * Graph Tool Definitions — GitNexus Knowledge Graph
+ * Graph Tool Definitions — CodeExplorer Knowledge Graph
  *
  * OpenAI function calling schemas for:
  * - analyze_impact: Blast radius analysis for symbol changes

package/dist/codebuddy/tool-definitions/index.d.ts

@@ -37,6 +37,6 @@ export { EXIT_PLAN_MODE_TOOL, EXIT_PLAN_MODE_TOOLS, } from './exit-plan-mode-too
 export { CODEBASE_REPLACE_TOOL, CODEBASE_REPLACE_TOOLS, } from './codebase-replace-tools.js';
 export { GENERATE_DOCUMENT_TOOL, DOCUMENT_GENERATOR_TOOLS, } from './document-tools.js';
 export { SESSION_TOOLS } from './session-tools.js';
-export { GITNEXUS_ASK_TOOL, GITNEXUS_TOOLS, } from './gitnexus-tools.js';
+export { CODE_EXPLORER_ASK_TOOL, CODE_EXPLORER_TOOLS, } from './code-explorer-tools.js';
 export type { CodeBuddyTool as Tool } from './types.js';
 export * from "./windows-tools.js";

package/dist/codebuddy/tool-definitions/index.js

@@ -68,7 +68,7 @@ export { CODEBASE_REPLACE_TOOL, CODEBASE_REPLACE_TOOLS, } from './codebase-repla
 export { GENERATE_DOCUMENT_TOOL, DOCUMENT_GENERATOR_TOOLS, } from './document-tools.js';
 // Session tools (multi-agent coordination — Phase E wake)
 export { SESSION_TOOLS } from './session-tools.js';
-// GitNexus tools
-export { GITNEXUS_ASK_TOOL, GITNEXUS_TOOLS, } from './gitnexus-tools.js';
+// CodeExplorer tools
+export { CODE_EXPLORER_ASK_TOOL, CODE_EXPLORER_TOOLS, } from './code-explorer-tools.js';
 export * from "./windows-tools.js";
 //# sourceMappingURL=index.js.map

package/dist/codebuddy/tools.d.ts

@@ -27,8 +27,8 @@ export declare function getBuiltinToolNames(): string[];
 export declare function initializeToolRegistry(): void;
 export declare function getMCPManager(): MCPManager;
 /**
- * True when the Code Explorer (gitnexus) MCP tools are connected — i.e. at least
- * one `mcp__gitnexus__*` tool is registered. Used to conditionally steer the
+ * True when the Code Explorer (code-explorer) MCP tools are connected — i.e. at least
+ * one `mcp__code-explorer__*` tool is registered. Used to conditionally steer the
  * agent toward Code Explorer for relationship/impact questions. Returns false
  * (no behavior change) whenever Code Explorer is not installed.
  */