Cline CLI v3.0.71 Released: Plugins Now Load In-Process, No JS Runtime Required
Cline CLI v3.0.71 overhauls plugin loading and fixes reasoning control, context estimation, and scheduled runs.
Cline CLI v3.0.71 is an infrastructure-focused update. The core change is the plugin architecture overhaul: plugins no longer run in separate Node/Bun subprocesses but load directly into the hub, removing the CLI's dependency on a JavaScript runtime in PATH. Plugin load failures now surface explicit warnings, with plugin_failure entries, a cline hub plugins status command, and --reload for individual reimports, plus CLINE_PLUGIN_MODE=sandbox to revert to sandbox mode. Additionally, --thinking now works in ACP mode and reasoning toggles are far more compatible across providers; screenshots and images no longer count toward token estimation, fixing premature auto-compaction; the model catalog adds several providers and adjusts many default models; and multiple defects in scheduled runs and the toolchain are resolved.
Cline CLI has released version v3.0.71, and the core change in this update centers on a redesign of the plugin architecture — plugins no longer run in separate Node or Bun processes, but are loaded directly into the hub. For developers who use Cline CLI daily to manage AI coding workflows, this means a substantial improvement in both the stability and observability of the plugin system.
Plugin Architecture Overhaul: From Subprocesses to In-Process Loading
Previously, Cline CLI plugins ran in separate Node or Bun subprocesses, which required a JavaScript runtime to be present in the user's PATH. v3.0.71 moves the plugin loading logic inside the hub process, eliminating this external dependency.
More importantly, failure visibility has improved. In the past, when a plugin failed to load, its tools would silently disappear — users wouldn't even know something had gone wrong. Now Cline prints a warning that explicitly identifies which plugin failed and what the error was. Two diagnostic entry points are provided alongside this: cline config tools --json lists failed plugins as plugin_failure entries, and the new cline hub plugins command shows the status and most recent error for each plugin. If you fix a plugin, you can use the --reload <plugin> flag to reimport it individually without restarting the entire hub.
For scenarios that depend on the old behavior or require special isolation, setting CLINE_PLUGIN_MODE=sandbox reverts to the original subprocess mode.
The Trade-offs Between Subprocess Isolation Mode and In-Process Loading
When plugins run in separate subprocesses (Node or Bun), each plugin has its own runtime, memory space, and crash boundary — if one plugin exits due to an uncaught exception, it won't take down the main process. The cost is inter-process communication (IPC) overhead, startup latency, and a hard dependency on a JavaScript runtime in the host's PATH. After switching to direct in-process loading within the hub, plugins share the same event loop and memory space as the main process — call paths are shorter and startup is faster, but exceptions or memory leaks thrown by plugins will directly affect the hub's stability. So the CLINE_PLUGIN_MODE=sandbox escape hatch is essentially a toggle between "isolation" and "lightweightness" — for plugins that need to run untrusted third-party code or depend on a specific runtime version, sandbox mode remains the safer choice.
ACP Mode and Reasoning Control Fixes
Users of --acp mode will find that the --thinking flag finally works. Previously, ACP sessions always ran with reasoning disabled, making --thinking effectively a no-op.
Compatibility for reasoning toggles has also been comprehensively fixed. Disabling reasoning now works correctly across all providers; for models that don't natively support disabling reasoning, their default behavior is preserved; Gemini models that only support a level parameter no longer reject requests due to thinking-budget errors.
Another notable fix involves provider configuration. Previously, even if you set a key like OPENROUTER_API_KEY in your environment variables, the TUI would still prompt you to manually configure the provider. Now, for providers that only read a single environment variable, startup will directly recognize them as configured.
The ACP Protocol and the thinking budget Parameter
ACP (Agent Client Protocol) is a protocol for passing session and tool-call messages between editors, terminal clients, and AI agent backends. Cline CLI exposes session capabilities in a protocol-compliant form via --acp. --thinking controls whether — and how much — a model exposes its "reasoning process"; for models that support this capability, it typically maps to the provider-side thinking budget (reasoning token budget) parameter. Different providers express this capability differently: some use a boolean toggle, others only accept token-level numeric values — certain Gemini models fall into the latter category, which is why disabling reasoning or passing incompatible parameters would cause direct errors. v3.0.71's approach is to adapt based on provider capabilities: disable if possible, preserve the model's default behavior if not, and for level-only models, switch to the field they recognize — avoiding entire request failures due to parameter format mismatches.
Context Management and Model Catalog Updates
Screenshots and images are no longer counted toward token estimation, which directly resolves the issue of auto-compaction triggering prematurely — previously, conversations with images would be compacted long before approaching the context limit. Additionally, when a model catalog entry lacks context window information, auto-compaction now uses the selected model's own context window for calculation.
When no model is selected, the Cline provider now defaults to the first model in the recommended list (Claude Sonnet 5.5).
The model catalog itself has also received a major refresh: three new providers added — AI/ML API, LowRouter, and Prime Inference; the v0 provider has been streamlined to offer only the default model v0-1.5-md; OpenCode Go has migrated to the new endpoint https://opencode.ai/inference/go/v1; and Step 5 Preview has been added to the Cline free list. Default models have changed for multiple providers, involving 302.AI, CrossModel, Cortecs, DigitalOcean, NEAR AI Cloud, Ofox, DevPass, LLM Gateway, Meta, Aixy, CloudFerro Sherlock, Moark, Ambient, NanoGPT, Neuralwatt, and Novita AI.
auto-compaction and Token Estimation Baselines
auto-compaction is the mechanism by which the agent automatically compresses conversation history and frees up space when approaching the model's context window limit. It relies on two inputs: the number of tokens currently occupied by the conversation, and the context window size available for that model. Previously, screenshots and images were counted in token estimation, and the token count derived from encoding visual content is often on the high side — causing conversations to be judged as "nearly full" long before truly hitting the limit, prematurely triggering compaction and losing context that could have been retained. v3.0.71 excludes images from estimation and, when a model catalog entry is missing context window metadata, falls back to the window value declared by the currently selected model itself — avoiding the use of an overly small denominator due to incomplete catalog information.
Scheduled Runs and Toolchain Fixes
Scheduled runs have been fixed for three previously existing issues: queued runs no longer remain stuck in pending status indefinitely; runs where the model call fails (e.g., the model has been retired) are marked as failed with an error message attached; and after a service interruption recovers, only the most recent missed time point is executed, rather than backfilling all missed runs during the outage.
Several fixes were also made in the toolchain: cline hook can now accept agent_error events, which previously caused it to error out and exit unresponsively; symlinked rule files now load correctly; skills under the .claude/skills directory are now discoverable; and editor tools no longer receive null as replacement text from certain models.
Summary
v3.0.71 is a version leaning toward infrastructure. The change in plugin loading method lowers the runtime environment barrier, improved observability of plugin failures means troubleshooting no longer relies on guesswork, and the fixes to context estimation and auto-compaction directly impact the reliability of everyday conversations. If you use plugins or depend on scheduled runs, this version is worth adopting sooner rather than later.
One-line Summary
Cline CLI v3.0.71 overhauled the plugin loading architecture and fixed issues with reasoning control, context estimation, and scheduled runs.
Paragraph Summary
Cline CLI v3.0.71 is an infrastructure-focused update. The core change is the plugin architecture overhaul: plugins no longer run in separate Node/Bun subprocesses but are loaded directly into the hub, so the CLI no longer depends on a JavaScript runtime in PATH. Plugin load failures are now explicitly reported, with plugin_failure entries, the cline hub plugins status query, and --reload for individual reimports, plus CLINE_PLUGIN_MODE=sandbox to revert to sandbox mode if needed. Additionally, --thinking now works in ACP mode, reasoning toggle compatibility across providers has been greatly improved; screenshots and images no longer count toward token estimation, fixing premature auto-compaction; the model catalog adds multiple providers and adjusts many default models; and numerous defects in scheduled runs and the toolchain have been resolved.
Related articles
Gaussian Mixture NPMLE Achieves Minimax Optimality: A New Breakthrough in Hellinger Distance
Recent research proves that the nonparametric maximum likelihood estimator (NPMLE) for Gaussian mixtures achieves the minimax optimal rate log(n)/n in squared Hellinger distance, with faster rates under compact support and empirical Bayes applications.
Quasipolynomial-Time Breakthrough for ℓ∞ Contractions: New Algorithm for Stochastic Games
The paper proposes a quasipolynomial-time algorithm for ℓ∞ contraction mappings, using a boosting argument to geometrically shrink the search region and deriving that simple stochastic games can be solved in quasipolynomial time, bringing new breakthroughs to algorithmic game theory and complexity theory.
The Independent Roles of Locality and Weight Sharing in Convolutional Neural Networks
A theoretical study using a teacher-student model reveals the independent roles of locality and weight sharing in CNNs: weight sharing accelerates learning without correlated inputs, but spatial correlation weakens its advantage, and locally connected networks achieve lower asymptotic error on correlated data.