kward 0.78.0 → 0.80.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e77436e5f94e314fcab35e347c16994eb8f92f990ad4c3ebdc6ab76a393cb1b4
-  data.tar.gz: 50b73b48c76c737d5b7d2534380547d94e357cac6dec4528a80cfe36ea8f6bdf
+  metadata.gz: e9128f608c2a864ad996598d285d4042758ea1bc1b3a76a1224984ef23129544
+  data.tar.gz: c9d718290398f95e1420e5e12225e43aaba6bf6c64c868fb6d175d5725aaf19d
 SHA512:
-  metadata.gz: bc17d7227fa1910ee107b840ec138ee19c8ed905d137d7aeed3fc552e2ec6d3aca1fb3d8df4febce7c7e84380a7e4f4378c3177415b3ab7a59fb22d344b92d2c
-  data.tar.gz: 56521cdb264f5745f2023a010892b99ec91693f4444c17c0f1aa7b9375e9d0727ba7c9ce280d4e0af9141ae5466073393fbf9d112d53bf7ea12872aa68c7f617
+  metadata.gz: 6b0e53fddfa2de055b11b6bbe0965496e2abc860162ed0888642bb353ae64e0e0fdbfbe14ed7412198c8c60583c1d55fd6d9cd7fec7a43eb37db456a494f5a1a
+  data.tar.gz: 2396aceedf67453422924616d92031160d3eee67ae448347d2f367a05d48a97d9ae39789b2100c3c47bdbc5925c85e4922146a50c72ee662d863f8ad597dacbd

data/.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ['3.2', 'ruby']
+        ruby-version: ['3.4', 'ruby']
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -27,11 +27,22 @@ jobs:
           ruby-version: ${{ matrix.ruby-version }}
           bundler-cache: true
 
+      - name: Install sandbox test dependency
+        run: sudo apt-get update && sudo apt-get install --yes bubblewrap
+
+      - name: Enable Bubblewrap namespaces
+        run: |
+          sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
+          sudo sysctl -w kernel.unprivileged_userns_clone=1
+          bwrap --ro-bind / / --unshare-net true
+
       - name: Check syntax
         run: find lib test -name '*.rb' -print0 | xargs -0 ruby -c
 
       - name: Check runtime warnings
-        run: ruby -w -Ilib -e 'require "kward"'
+        run: bundle exec ruby -w -Ilib -e 'require "kward"'
 
       - name: Run tests
+        env:
+          KWARD_RUN_BUBBLEWRAP_TESTS: "1"
         run: bundle exec rake test

data/.github/workflows/pages.yml

@@ -25,7 +25,7 @@ jobs:
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: '3.3'
+          ruby-version: '3.4'
           bundler-cache: true
 
       - name: Build documentation

data/CHANGELOG.md

@@ -2,7 +2,88 @@
 
 All notable changes to Kward will be documented in this file.
 
-## [Unreleased]
+## [0.80.0] - 2026-07-27
+
+### Added
+
+- Added HTML/Ruby syntax highlighting and common-block auto-indentation for `.erb` files in the integrated editor.
+- Added catalog-based API-key login and model selection for OpenAI, Anthropic, Azure OpenAI, Gemini, Cerebras, DeepSeek, Fireworks AI, Groq, Mistral, NVIDIA NIM, OpenRouter, Together AI, and xAI, with private credential storage and live/cached/curated model catalogs.
+- Added native streaming runtimes for the OpenAI Responses API, Google Gemini, and Azure OpenAI, including tool calls, usage metadata, retries, cancellation, and secret redaction.
+- Added RPC parity for provider/auth-method discovery, sanitized credential status, API-key login/logout, model refresh, and provider/model selection.
+- Added a dedicated model-provider guide with the canonical provider list, runtime IDs, authentication, model configuration, discovery behavior, and limitations.
+- Added a prompt-template guide, including template creation, slash-command expansion, and the starter templates installed by `kward init`.
+- Added a Stardate footer plugin example for the interactive CLI.
+- Added a general transport plugin API with normalized messages and events, persistent transport state, policy checks, managed lifecycle, foreground CLI commands, and RPC capability/status reporting.
+- Added a first-party Telegram long-polling transport example with fixed-workspace routing, numeric allowlists, idempotent updates, message chunking, and interactive approval/question buttons.
+- Added packaged plugin entrypoints under `~/.kward/plugins/*/plugin.rb` for multi-file trusted plugins.
+- Added generic transport execution profiles and an isolated Telegram chat transport with no tools, plugin commands, memory, attachments, or interactions.
+- Added a shared scoped plugin-chat runtime and `Transport::Host#plugin_chats` for explicitly transport-capable plugin chats, including actor context, event replay, cancellation, and separate transport/RPC access.
+- Added transport-only plugin chats with `local: false`, keeping externally targeted plugin chats out of local tab opening and restoration.
+- Added Git worktree bindings for normal interactive session tabs. `/tab worktree` can move a tab into a strict linked-worktree workspace after research, preserve its transcript, warn about dirty origin changes, and keep the branch available when explicitly detached.
+- Added the active worktree `git_commit` model tool, allowing explicitly requested agent commits through the trusted host-side Git workflow without widening the shell sandbox.
+- Added `/tab worktree merge` for explicitly merging a clean worktree branch into the branch checked out in its original workspace, plus `/tab worktree merge abort` for conflicted merges.
+- Added `j`/`k` keyboard navigation to the `/files` project browser.
+- Added `h`/`l` keyboard navigation for collapsing and expanding `/files` directories.
+- Added `j`/`k` keyboard navigation to the `/git` changed-file overlay.
+
+### Changed
+
+- Avoided copying bounded transcript buffers into idle tab snapshots while preserving intentional full-conversation scrollback replay when those tabs are revisited.
+- Kept the TUI transcript buffer under its existing limit while trimming to a safe low watermark instead of copying the full buffer after every appended character.
+- Reduced integrated-editor layout work by caching line starts and calculating the cursor line once per rendered frame.
+- Limited interactive plugin footer evaluation to its authoritative one-second refresh interval and reused the cached value between refreshes.
+- Made interactive plugin canvases publish only complete frames submitted with `ui.render`, skip unpublished ticks, and follow terminal width changes.
+- Avoided rebuilding and flushing the TUI composer when tab labels and selection have not changed.
+- Reduced interactive streaming overhead by writing each labeled TUI delta in one synchronized prompt transaction.
+- Highlighted the current editor line number in white while keeping the rest of the line-number gutter green.
+- Made `/model` provider-aware with refresh, manual model IDs, capability-filtered defaults, Show all, and provider switching while preserving Codex, Copilot, OpenRouter, and local models.
+- Kept direct OpenAI API credentials (`openai_api`) separate from ChatGPT/Codex OAuth so both can be configured at once.
+- Azure OpenAI setup now validates HTTPS endpoints, deployment names, and API versions, and treats the configured deployment as the selectable model.
+- Updated current documentation to describe Copilot and the JSON-RPC backend as supported features rather than experimental ones.
+- Clarified the distinct roles of workspace guardrails, tool permissions, and command sandboxing.
+- Reorganized the README documentation index and clarified generated Ruby API support boundaries.
+- Added task-oriented navigation to the RPC and configuration references.
+- Standardized MCP support and limitation wording across the user and RPC guides.
+- Reframed the README introduction around Kward as an Agentic Development Environment (ADE) with opt-in safety controls.
+- Moved the local-model setup guide to the generated documentation Integrate navigation.
+- Added the Telegram transport deployment guide to the generated documentation navigation.
+- Replaced implicit `/tab worktree` detachment with explicit `/tab worktree detach`; running `/tab worktree` again now leaves an active worktree enabled.
+- Added workspace overrides for foreground transports via `kward transport run NAME WORKSPACE` and the global `--working-directory` option.
+- The `/files` project-browser now uses full terminal height if there are enough files to fill that space
+
+### Fixed
+
+- Prevented a stopped tab live-view thread from resuming against a newly active tab after a slow render.
+- Kept `@`/`$` completion, `/files`, prompt history, and the integrated editor rooted in the active worktree tab instead of the original checkout.
+- Fixed HTML and ERB editor highlighting so tag names, attributes, values, and tag fragments retain consistent colors across embedded Ruby expressions.
+- Refreshed composer diff and context usage status immediately when switching session tabs.
+- Prevented `/reload` from retaining stale prompt templates, so new and edited prompt files refresh slash-command completion and expansion.
+- Prevented session-picker rename input from filtering the visible session list.
+- Fixed session listing timestamps and ordering to ignore system-prompt and other metadata writes during session restoration.
+
+## [0.79.0] - 2026-07-19
+
+### Added
+
+- Added a Local OpenAI-compatible model provider for Ollama, LM Studio, and llama.cpp, including model discovery, streamed tool calls, configurable context windows, CLI/RPC model selection, and a local-model setup guide.
+- Added replacement system-prompt files and an option to omit global principles for smaller-model prompt budgets.
+- Added skill capture from saved session branches. Review model-generated personal `SKILL.md` drafts in the CLI or Pan, or use the equivalent RPC workflow before explicitly saving them.
+- Added opt-in OS-enforced sandboxing for model-requested shell commands. macOS uses Seatbelt and Linux uses Bubblewrap when available; requested sandboxing fails closed when no supported backend can enforce it. The interactive `/sandbox` command reports and updates the global policy.
+
+### Changed
+
+- Clarified command-sandbox configuration, platform setup, and limits across the security, permissions, workspace-tools, RPC, and configuration guides.
+- Sandboxed command workers now receive a sanitized environment with a private home and temporary directory; the macOS backend also blocks reads from common credential directories.
+- Improved built-in tool guidance so agents use only tools advertised for the current turn and select code search, compacted-output retrieval, and structured clarification when appropriate.
+- Raised the minimum supported Ruby version from 3.2 to 3.4.
+
+### Fixed
+
+- Reject duplicate discovered tool names instead of silently replacing one MCP tool with another.
+- Fixed an RPC race where follow-up input could queue instead of steering a turn immediately after it began.
+- Prevented the RPC server from loading trusted Ruby plugins separately for plugin chats and workspace sessions, eliminating duplicate constant-definition warnings during startup.
+- Prevented `/reload` and RPC runtime reloads from emitting duplicate constant-definition warnings for plugin-defined constants.
+- Wrapped long side-by-side diff cells when editor soft wrap is enabled instead of clipping their contents.
 
 ## [0.78.0] - 2026-07-15
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kward (0.78.0)
+    kward (0.80.0)
       base64
       nokogiri
       tiktoken_ruby
@@ -146,7 +146,7 @@ CHECKSUMS
   html-proofer (5.2.1) sha256=fdd958a7cbf9c3255fb96fe7cfc4e611f64e2706e469488a3326309ad007d2fd
   io-event (1.16.2) sha256=9f9cb0a96ea5c3850a672606c65f27bc96d7621399ef6196acbfe2be0cd1279c
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
-  kward (0.78.0)
+  kward (0.80.0)
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
   metrics (0.15.0) sha256=61ded5bac95118e995b1bc9ed4a5f19bc9814928a312a85b200abbdac9039072
   minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1

data/README.md

@@ -1,29 +1,16 @@
 # Kward
 
-Kward is an extendable Ruby CLI coding agent. It can chat with you about a project, inspect and edit files, run confirmed shell commands, search the web, look up public source code, save local sessions, and load trusted Ruby plugins for custom workflows.
+Kward is a coding agent for your terminal. It can inspect and edit a project, run commands, research problems, and save your work in sessions you can resume later.
 
-It currently supports the OpenAI/ChatGPT Codex backend, Anthropic Claude Pro/Max subscription, OpenRouter, and experimental Copilot provider support.
+Use Kward from the terminal, its local browser interface, or a trusted JSON-RPC client. It works with ChatGPT/Codex and Claude subscriptions, hosted model APIs, GitHub Copilot, OpenRouter, and local servers such as Ollama, LM Studio, and llama.cpp.
 
-## Why use Kward?
+## Why Kward?
 
-Kward is designed for working with real projects, not isolated prompts.
+Software work rarely fits into one chat. A project can span days of research, implementation, debugging, review, and decisions worth keeping.
 
-Typical workflows include:
+Kward treats that work as an ongoing workspace rather than a disposable conversation. You can resume earlier sessions, split work across tabs and Git worktrees, and keep project guidance close to the code. Optional permissions, command sandboxing, and workspace boundaries give you more control when a task needs it.
 
-- Understanding an unfamiliar codebase
-- Investigating bugs
-- Reviewing changes
-- Refactoring code
-- Automating repetitive development tasks
-- Building custom agent workflows through plugins
-
-Examples:
-
-```bash
-kward "Explain this project"
-kward "Review this diff"
-kward "Find performance problems in this codebase"
-```
+Start with a normal coding conversation. If your workflow grows, you can add memory, reusable prompts and skills, local plugins, lifecycle hooks, MCP servers, transports, or a custom RPC client.
 
 ## Install
 
@@ -52,55 +39,63 @@ kward "Explain this project"   # run one prompt and exit
 kward --working-directory ~/code/project "Explain this project"
 ```
 
-From inside Kward, `/login` opens the same provider picker.
+From inside Kward, `/login` lets you choose API-key or subscription authentication across supported providers. `/model` then switches providers, refreshes model catalogs, or accepts a manual model/deployment ID. Direct OpenAI API credentials and ChatGPT/Codex OAuth can coexist.
 
-See [Authentication](doc/authentication.md) for more details about sign-in options and provider credentials.
+See [Model providers](doc/providers.md) to choose a backend and [Authentication](doc/authentication.md) for credential storage and login flows.
 
-## What Kward can do
+## Common ways to use Kward
 
-- Keep a multi-turn coding conversation in your terminal.
-- Read, write, and edit workspace files with read-before-write guardrails.
-- Run local shell commands from the workspace.
-- Search the live web and inspect cached public GitHub repositories.
-- Save, resume, clone, compact, and export sessions.
-- Extend the Agent with trusted Ruby plugins for custom commands, footer UI, prompt context, and transcript-event observers.
-- Use optional memory, personas, prompt templates, and skills.
-- Serve a JSON-RPC backend for trusted local UI clients.
+- Explore an unfamiliar codebase and keep useful discoveries for later sessions.
+- Investigate a bug, make a focused change, and run the related tests.
+- Review a diff, inspect the surrounding code, and commit from the terminal UI.
+- Work on several tasks at once with tabs, branches, and linked Git worktrees.
+- Teach Kward your project conventions with `AGENTS.md`, skills, prompt templates, and optional memory.
+- Add trusted local behavior through plugins, lifecycle hooks, MCP servers, transports, or JSON-RPC integrations.
 
 ## Documentation
 
-Start here:
+New to Kward:
 
 - [Getting started](doc/getting-started.md): first run, authentication choices, and basic commands.
 - [Usage](doc/usage.md): interactive chat, slash commands, sessions, tools, images, and Pan mode.
 - [Configuration](doc/configuration.md): config files, providers, models, web search, logging, and color output.
-- [Authentication](doc/authentication.md): OpenAI OAuth, Anthropic OAuth, OpenRouter API keys, and Copilot/GitHub setup.
+- [Authentication](doc/authentication.md): multi-provider API keys, OpenAI/Anthropic subscription OAuth, Azure setup, and credential safety.
+- [Model providers](doc/providers.md): compare providers and find their runtime IDs, model keys, environment variables, discovery behavior, and limitations.
+
+Work safely:
+
 - [Security and trust](doc/security.md): local permissions, external data flow, trusted extensions, and safe work in unfamiliar repositories.
 - [Permissions](doc/permissions.md): opt-in tool approval, write scopes, policy rules, and current limits.
+- [Command sandboxing](doc/sandboxing.md): opt-in OS-enforced boundaries for model-requested shell commands.
 - [Troubleshooting](doc/troubleshooting.md): environment-specific install and runtime issues.
 
-Feature guides:
+Everyday workflows:
 
 - [Sessions](doc/session-management.md): resume, clone, fork, rewind, compact, and navigate saved work.
 - [Interactive composer](doc/composer.md): use multiline input, completion, history, files, reasoning shortcuts, busy input, and images.
 - [Tabs](doc/tabs.md): keep several conversations open and run work in another tab.
 - [Project files](doc/files.md): browse, search, mention, open, and edit workspace files.
-- [Integrated Editor](doc/editor.md): open files from the shell or composer, edit in-place, and choose editor keybindings.
+- [Integrated editor](doc/editor.md): open files from the shell or composer, edit in-place, and choose editor keybindings.
 - [Git](doc/git.md): review changes, use the diff viewer, stage files, and commit from the interactive TUI.
 - [Shell](doc/shell.md): use `/shell`, the embedded Kward shell with aliases, completion, and per-tab state.
 - [Memory](doc/memory.md): opt-in core, soft, and session memory.
 - [Personas](doc/personas.md): configure Kward's tone and role by default, workspace, model, reasoning effort, time, and weekday.
 - [Skills](doc/skills.md): add reusable instructions that load only for matching tasks.
+- [Prompt templates](doc/prompt-templates.md): create reusable slash prompts and use the starter templates installed by `kward init`.
 - [MCP servers](doc/mcp.md): connect trusted local Model Context Protocol tool servers.
 - [Pan mode](doc/pan.md): use the mobile-friendly browser interface on a trusted local network.
+- [Local models](doc/local-models.md): connect Ollama, LM Studio, or llama.cpp and use a minimal replacement prompt.
 
-Advanced:
+Extend and integrate:
 
-- [Extensibility](doc/extensibility.md): `PRINCIPLES.md`, workspace `AGENTS.md`, skills, prompt templates, and extension choices.
+- [Extensibility](doc/extensibility.md): choose between `PRINCIPLES.md`, workspace `AGENTS.md`, skills, prompt templates, and other extension points.
 - [Plugins](doc/plugins.md): trusted Ruby plugins for commands, footer UI, prompt context, transcript events, and RPC clients.
 - [Lifecycle hooks](doc/lifecycle-hooks.md): deterministic runtime hooks for policy, approvals, automation, and command-hook integrations.
 - [RPC protocol](doc/rpc.md): JSON-RPC backend mode for trusted local UI clients.
 - [Releasing](doc/releasing.md): release checklist for RubyGems publishing.
+
+Reference guides:
+
 - [Agent tools](doc/agent-tools.md): overview of model-callable tools, token-saving behavior, and tool categories.
 - [Workspace tools](doc/workspace-tools.md): local file, edit, and shell command tools.
 - [Context budgeting](doc/context-budgeting.md): focused context gathering, budgeted reads, output compaction, and token-saving history.
@@ -108,9 +103,9 @@ Advanced:
 - [Code search](doc/code-search.md): package lookup, GitHub repository cache, and external source reading for the code search agent tool.
 - [Context tools](doc/context-tools.md): skills, compacted output retrieval, and structured clarification questions.
 
-API reference:
+Generated Ruby API:
 
-- [API reference](doc/api.md): generated Ruby API entry points, indexes, and public API expectations.
+- [API reference](doc/api.md): generated Ruby API entry points, indexes, and supported API expectations.
 
 ## Development
 

data/doc/agent-tools.md

@@ -2,14 +2,13 @@
 
 Agent tools are the model-callable operations Kward uses to inspect projects, change files, run commands, search outside sources, and ask for clarification. Most users do not call these tools directly. You ask for an outcome in natural language, and Kward decides which tools are needed.
 
-Tools are part of Kward's safety and context-management boundary:
+Tools also enforce important boundaries:
 
-- schemas describe what the model is allowed to call,
-- Ruby tool objects validate and execute those calls,
-- workspace tools stay inside the active workspace by default (see [Configuration](configuration.md) for the guardrail setting),
-- file-changing tools require the file to be read first,
-- large outputs are bounded or compacted before they enter model context,
-- full tool outputs are kept in the session record for later inspection.
+- Kward validates every tool call before running it.
+- Workspace tools stay inside the active workspace by default (see [Configuration](configuration.md) for the guardrail setting).
+- File-changing tools require the file to be read first.
+- Large outputs are bounded or compacted before they enter model context.
+- Full tool outputs remain available in the session record for later inspection.
 
 ## Tool categories
 
@@ -22,7 +21,7 @@ Tools are part of Kward's safety and context-management boundary:
 
 ## How tools save tokens
 
-Kward tries to keep tool context useful without flooding the model. The built-in prompt tells Kward to start with focused context tools and escalate from outlines/previews to exact ranges before full-file reads:
+Kward tries to gather enough evidence without flooding the conversation. It usually starts with focused context tools, then moves from outlines and previews to exact ranges or full files only when needed:
 
 - `read_file` reads bounded line ranges, supports continuation with `offset` and `limit`, and accepts explicit `preview`, `outline`, `range`, and `full` modes with optional per-call byte budgets.
 - `context_for_task` builds a task-shaped bundle from ranked files, outlines, and matching excerpts within a caller-supplied byte budget.
@@ -32,13 +31,13 @@ Kward tries to keep tool context useful without flooding the model. The built-in
 - Repeated identical tool output is replaced with a short reference instead of being sent again.
 - Compacted outputs are stored as artifacts that can be reopened with `retrieve_tool_output`, including after resuming a saved session that contains the original tool execution record.
 
-When a tool output exceeds 12 KB, Kward compacts it before sending it to the model. The compactor preserves the first 40 and last 40 lines, keeps lines matching error, test, or search-result patterns with 2 lines of surrounding context, and replaces omitted sections with `[... omitted lines ...]` markers. Shell command output is section-aware: STDOUT and STDERR sections are compacted separately. Compacted outputs include a header with the original and compacted byte counts and the artifact ID for retrieval. Error outputs under 8 KB are left intact so failure details stay visible.
+When output exceeds 12 KB, Kward keeps the most useful sections in context and stores the original output for later retrieval. The compacted result includes an artifact ID, so Kward can reopen an exact section without repeating the tool call. Error output under 8 KB stays intact so useful failure details are not lost.
 
-This lets the assistant reason from focused evidence while preserving access to original outputs when needed. For a fuller overview of Kward's context budgeting and token-saving work, see [Context budgeting](context-budgeting.md).
+See [Context budgeting](context-budgeting.md) for the full compaction strategy, limits, and token-saving workflow.
 
 ## How tools are exposed
 
-`Kward::ToolRegistry` builds the available tool objects and the schemas advertised to the model. Some tools are always available in normal CLI/RPC sessions, while others depend on configuration or frontend capability:
+`Kward::ToolRegistry` builds the available tool objects and the schemas advertised to the model. Kward instructs models to call only tools advertised for the current turn; a restricted RPC turn therefore receives schemas only for its selected set. Some tools are always available in normal CLI/RPC sessions, while others depend on configuration or frontend capability:
 
 - web tools can be hidden with web search configuration,
 - `read_skill` is advertised only when skills are available,

data/doc/api.md

@@ -1,8 +1,8 @@
 # API reference
 
-Kward's generated Ruby API documentation is mainly for contributors, plugin authors, tool authors, and people building RPC or editor integrations.
+Kward's generated Ruby API documentation is for contributors, plugin authors, tool authors, and people building RPC or editor integrations.
 
-If you use Kward from the terminal, start with the [user guides](file.README.html#Documentation) instead. The API reference exposes many internal classes because it is generated from the source tree; not every documented class is a stable extension API.
+If you use Kward from the terminal, start with the [user guides](file.README.html#Documentation). This reference also includes internal classes and methods that may change. Treat the behavior described in the guides, the Plugin DSL, and the methods in the [RPC protocol](rpc.md) as Kward's supported public interfaces.
 
 ## Start here
 
@@ -84,7 +84,7 @@ The generated comments focus on these supported extension boundaries rather than
 
 ## Public API expectations
 
-Kward is still evolving. The generated reference is useful for understanding the codebase, but it should not be read as a promise that every class, method, or constructor is public and stable.
+The generated reference is useful for understanding the codebase, but it does not make every class, method, or constructor a supported public API.
 
 Prefer the documented guides for supported extension behavior. Use generated class and method pages when you need implementation detail, are contributing to Kward itself, or are coordinating a frontend integration with the current codebase.