1jehuang/jcode
50.6
Adequate · 14 November 2026
717.1k
lines of production code
Rust
primary language
5
measurements over time
What this system is
Features
Add Grok Build provider with HTTPS chat proxy support
Users can now use the Grok Build subscription via a new provider that connects directly to the Grok CLI chat proxy over HTTPS, eliminating the need to launch a grok subprocess. The implementation reuses the OpenAI-compatible runtime for streaming and tool execution, authenticates using the existing Grok CLI OIDC session, and includes automatic retry logic to handle token expiration (HTTP 401) by refreshing the bearer token and replaying the request once.
crates/jcode-provider-grok-build-runtime · high confidence
Add cross-platform local IPC transport crate
The new \jcode-transport\ crate provides a unified local IPC API that abstracts away platform differences: it uses Unix sockets on Unix-like systems and Windows named pipes on Windows, exposing a consistent \Listener\ and \Stream\ interface. This allows the harness API bridge to communicate with the SDK on both platforms without duplicating platform-specific code or depending on the broader \jcode-base\ foundation.
crates/jcode-transport/src · high confidence
Added benchmark examples for fuzzy matching performance
Two new example programs, bench.rs and bench\_realistic.rs, have been added to the jcode-fuzzy crate to demonstrate and measure fuzzy matching performance. bench.rs provides a simple benchmark using the fuzzy\_score\_tokens function, while bench\_realistic.rs demonstrates the new PreparedTokenQuery API for more efficient per-keystroke filtering against a larger, realistic dataset of model names.
crates/jcode-fuzzy/examples · high confidence
Added light-palette benchmark example
A new example file \light\_bench.rs\ has been added to the \jcode-tui-style\ crate. This tool allows users to evaluate and tune light-background color palettes by scoring them against a harmony analyzer. It includes a default 'flipped' palette generation method and a hand-tuned candidate designed for color-blindness safety and visual harmony, providing a deterministic coordinate-descent tuner to optimize palette scores.
crates/jcode-tui-style/examples · high confidence
Added reference REPL client for the Harness API
A new example client (harness\_repl.rs) is provided to demonstrate how to interact with the Harness API over a Unix socket. It supports a live mode for connecting to a real server and a --demo mode that exercises the client against a scripted in-process server, covering the handshake, session creation, message sending, and event streaming.
crates/jcode-harness-api/examples · high confidence
Added write\_dev\_sidecar example for self-dev builds
A new example, write\_dev\_sidecar, has been added to the jcode-build-support crate to help developers working with direct self-dev builds. When building outside the coordinated build queue, the resulting binary may lack an up-to-date .source.json sidecar, causing selfdev reload to fail; this example stamps the binary with the current source state to resolve that issue.
crates/jcode-build-support/examples · high confidence
Build-time documentation bundling for the application core
The \jcode-app-core\ crate now includes a \build.rs\ script that automatically scans the repository's \README.md\ and all Markdown files in the \docs/\ directory at compile time. These files are embedded into the binary as a static array, making the full documentation corpus available to the application without requiring external file access at runtime. Also in this area: Durable scheduled task persistence and external blocker review support; Improved search cancellation and background task guidance; Browser workflow now allows password fields and restricts handoff to CAPTCHA-only scenarios; Desktop companion takes over system-level tasks and terminal rendering is removed from the server; Fixes for agent tool-call recovery, session route healing, and swarm stability.
(repo-wide) · high confidence
Cross-platform global launch hotkeys and CLI shortcut reminders
Jcode now installs and manages global launch hotkeys on macOS, Windows, and Linux (including niri, Hyprland, sway, i3, GNOME, KDE, and others) to open sessions in specific directories. On Linux, it splices bind lines into compositor configs; on macOS, it registers system-wide shortcuts via a launchd listener; on Windows, it sets up native hotkeys. Additionally, it detects external AI coding CLIs (Claude Code, Codex) and shows a one-time desktop notification reminding users of the Jcode launch shortcut, with cooldowns and usage tracking to avoid repetition.
crates/jcode-setup-hints/src · high confidence
Cursor provider runtime moved to dedicated crate with native agent transport
The Cursor provider runtime has been extracted from jcode-base into the new jcode-provider-cursor-runtime crate to improve build times and isolate provider-specific logic. This change introduces a native AgentService/Run transport that replaces the deprecated ChatService endpoint, handling the specific Connect-over-HTTP/2 framing and pacing required by the Cursor CLI. It also adds logic to resolve the regional agent host from the local CLI config or environment overrides, ensuring connectivity for region-pinned teams, and includes tests for model catalog merging and persistence.
crates/jcode-provider-cursor-runtime · high confidence
Detects keybinding conflicts with terminal and OS shortcuts
The setup-hints module now scans your machine for keybindings declared by your terminal emulator (via \ghostty +list-keybinds\), macOS system shortcuts, and external apps like window managers (OmniWM, AeroSpace). It compares these against your configured jcode keys and, if overlaps are found, displays a one-time startup warning and provides a \/keys\ command to view a detailed diagnostic report, helping you resolve silent key capture issues.
crates/jcode-setup-hints/src/keymap · high confidence
Expanded session picker with multi-agent support and directory filtering
The session picker now supports sessions from external CLI agents including Claude Code, Codex, Pi, OpenCode, and Cursor, displaying specific badges for each source. Users can filter sessions by the current working directory, view active sessions with streaming status, and see the first user prompt in the resume list. The picker also introduces an 'ExternalClis' composite filter for onboarding to surface all connected external tools.
crates/jcode-tui-session-picker · high confidence
Extracted TUI Markdown Renderer with LaTeX, Mermaid, and Table Support
The TUI markdown rendering logic has been extracted into a dedicated crate (\jcode-tui-markdown\) to decouple the foundation layer from terminal-specific dependencies. This new module provides a comprehensive markdown renderer for the terminal UI, featuring support for Mermaid diagrams (with deferred background rendering and fallbacks), LaTeX math (rendered as images via Handterm or external toolchains, with caching to prevent UI freezes), and aligned ASCII tables. It also includes incremental rendering for streaming text, configurable display modes for diagrams and spacing, and specific styling for reasoning blocks (dim/italic).
crates/jcode-tui-markdown/src · high confidence
Guided Google Cloud OAuth setup with gcloud automation
Users can now set up their own Google Cloud OAuth credentials through an automated guided flow. The new setup module detects the local gcloud CLI status, automatically creates a new Google Cloud project and enables required APIs if gcloud is installed and authenticated, and provides deep links to the Google Cloud Console for manual steps like configuring the OAuth consent screen and publishing the app. It also includes logic to validate generated project IDs and detect expired grants caused by the 7-day testing mode limit.
crates/jcode-base/src/auth/google · high confidence
Initial project documentation and governance files added
The repository now includes foundational documentation files: AGENTS.md defines the development workflow and Git identity requirements, CONTRIBUTING.md outlines the policy for accepting pull requests from all contributors, OAUTH.md details the authentication flows for various providers, RELEASING.md documents the CI and local release processes, TELEMETRY.md explains the data collection practices, and LICENSE establishes the MIT license terms.
(repo-wide) · high confidence
Introduce AWS Bedrock provider with scoped authentication and optional SDK dependency
Adds a new Bedrock provider crate that enables users to interact with AWS Bedrock models. The implementation scopes authentication by configuring bearer tokens directly on the runtime and control clients rather than mutating process-wide environment variables, preventing credential leakage between concurrent routes. It resolves AWS login profiles natively via the AWS SDK instead of invoking the AWS CLI, and the entire AWS SDK stack is optional, gated behind a feature flag to allow building without Bedrock support. Also in this area: Isolated test environment for Bedrock provider credentials.
crates/jcode-provider-bedrock · high confidence
Introduce Antigravity provider runtime crate with model catalog and test coverage
The Antigravity provider runtime has been moved out of \jcode-base\ into a new standalone crate (\crates/jcode-provider-antigravity-runtime\) to improve build times and isolation. This crate implements the \AntigravityProvider\, which manages model selection by fetching and persisting a live model catalog (including quota and reset metadata), resolving the \"default"\ model alias to a concrete backend model, and exposing diagnostic helpers for the provider doctor. Comprehensive tests have been added to verify catalog parsing, persistence, stale-catalog handling, and model resolution logic.
crates/jcode-provider-antigravity-runtime · high confidence
Introduce MCP client implementation with schema caching and per-server timeouts
This change adds the core Model Context Protocol (MCP) client infrastructure to \jcode-base\, enabling the application to connect to, manage, and call tools on external MCP servers. It introduces a shared server pool to reuse server processes across sessions, while ensuring that non-shared (owned) servers run in the correct session working directory and do not inherit the daemon's provider credentials. To improve startup performance, a disk-based schema cache stores tool definitions, allowing tools to be advertised immediately even before the server handshake completes. Additionally, users can now configure a per-server \timeout\_secs\ to control request reply limits, and tool names are automatically sanitized to ensure compatibility with provider-specific naming constraints.
crates/jcode-base/src/mcp · high confidence
Introduce TypeScript SDK and platform runtime packages
The SDK now ships as a TypeScript package (\@1jehuang/jcode-sdk\) alongside platform-specific runtime packages for macOS (darwin-arm64, darwin-x64), Linux (linux-arm64, linux-x64), and Windows (win32-arm64, win32-x64). This allows users to install the SDK and automatically get the correct native runtime for their architecture, enabling features like \JcodeClient.launch()\ to start a private instance without a separate Rust toolchain. The release includes a runnable demo application, streaming chat examples, and comprehensive end-to-end tests covering session controls, credential inheritance, and isolation guarantees.
sdk · high confidence
Introduce TypeScript SDK for the jcode harness API
Adds a new TypeScript SDK that allows applications to connect to the jcode harness API, launch private jcode instances, and manage sessions. The SDK provides a \JcodeClient\ for connecting via Unix sockets (with named pipe support on Windows), launching isolated daemon instances with inherited credentials, and interacting with sessions through a structured event stream. Key capabilities include creating and forking sessions, sending messages with image attachments, running structured output with JSON Schema validation, defining and executing custom session tools with timeouts, and managing file operations. The SDK handles connection errors with descriptive messages, manages tool callbacks with abort signals, and ensures proper cleanup of instance daemons.
sdk/typescript · high confidence
Introduce account-only browser login flow
The base crate now includes a dedicated account-only login module that implements the OAuth 2.0 device authorization flow. This allows Desktop and other async clients to authenticate users via a browser without automatically selecting a provider, activating billing, or waiting for a paid plan. The implementation handles device code polling, URL validation, and credential redaction, separating the sign-in step from subscription checkout.
crates/jcode-base/src · high confidence
Introduce backend-neutral render core for shared markdown and math rendering
A new \jcode-render-core\ crate provides a backend-neutral document model that parses Markdown (including tables, task lists, and nested lists) and renders LaTeX math into Unicode text, separating the parsing and layout logic from backend-specific drawing. This allows both the ratatui TUI and the desktop GPU UI to share the same rendering foundation, with each frontend providing a thin adapter to resolve semantic styles and width measurements for its specific environment.
crates/jcode-render-core/src · high confidence
Introduce centralized message and tool type definitions
The \jcode-message-types\ crate now provides the core data structures for conversation history and tool interactions. This includes the \Message\ and \ContentBlock\ types, which support various content formats such as text, reasoning traces, and provider-specific thinking blocks (Anthropic signed thinking, OpenAI reasoning). It also defines \ToolCall\ and \ToolDefinition\, introducing support for deferred tool loading to prevent prompt cache invalidation and including fields for Gemini 3 thought signatures to ensure compatibility with backend requirements.
crates/jcode-message-types · high confidence
Introduce core compaction logic and token accounting constants
This change introduces the \jcode-compaction-core\ crate, establishing the foundational constants and data structures for context window management. It defines token budgets (200k limit), compaction thresholds (80% trigger, 95% critical), and specific accounting rules for inline images (fixed 1,600 token cost) to prevent runaway compaction cycles. The module also provides the core logic for generating compaction prompts and summarizing conversation history, serving as the central engine for context optimization.
crates/jcode-compaction-core · high confidence
Introduce core library for overnight run orchestration and reporting
This change adds the \jcode-overnight-core\ crate, establishing the foundational data models and logic for the overnight automation feature. It defines the \OvernightManifest\ and \OvernightEvent\ structures that track run state, timing, and progress, alongside DTOs for task cards, resource snapshots, and usage projections. The crate also includes the prompt engineering logic for the coordinator agent, providing specific system prompts for both hidden background runs and visible current-session modes, as well as helpers for generating human-readable status summaries and HTML review pages.
crates/jcode-overnight-core · high confidence
Introduce dedicated Gemini provider crate with schema hardening and model support
This change introduces the \jcode-provider-gemini\ crate, establishing the core data structures and constants for the Gemini integration. It defines the available and fallback model lists (including \gemini-2.5-pro\ and various \gemini-3\ previews) and configures the API endpoints for both the official Google AI Studio and Code Assist. The implementation hardens the JSON schema parsing by defaulting the \role\ field in response content to prevent deserialization failures when the API omits it, and it introduces a \thought\_signature\ field to \GeminiPart\ to support replaying thought signatures required by the Cloud Code backend.
crates/jcode-provider-gemini · high confidence
Introduce dedicated OpenRouter provider crate with robust streaming and tool handling
This change introduces the \jcode-provider-openrouter\ crate, extracting OpenRouter-specific logic into a dedicated module. It adds a new \OpenRouterStream\ implementation that correctly handles SSE event boundaries (including CRLF delimiters) and preserves incomplete UTF-8 sequences across chunk boundaries to prevent data loss. The crate also includes a \sanitize\_tool\_parameters\_schema\ function to normalize tool schemas for strict upstream compatibility and a \build\_chat\_messages\ function that preserves orphaned and repeated tool outputs, ensuring reliable tool-use interactions.
crates/jcode-provider-openrouter · high confidence
Introduce dedicated email notification backend for sending and polling
A new \jcode-notify-email\ crate has been added to handle email-based notifications. This component provides functionality to send HTML emails via SMTP (supporting STARTTLS and authentication) and to poll an IMAP inbox for user replies. It specifically parses incoming messages to detect permission decisions (approve/deny) and directive replies based on subject lines and reply headers, enabling asynchronous user interaction through email.
crates/jcode-notify-email · high confidence
Introduce deterministic risk assessment and reflection gate for shell commands
This change adds a new \jcode-command-risk\ crate that implements a two-stage safety gate for shell commands to prevent accidental data loss (issue \#604). Stage 1 is a deterministic classifier that analyzes command syntax and target paths to assign a risk level (Safe, Low, Confirm, or Catastrophic), covering destructive verbs like \rm\ and \shred\, redirect truncation, and credential store access. Stage 2 is a reflection gate that blocks 'Catastrophic' commands outright and requires the generating model to provide a substantive justification for 'Confirm' level commands before execution. The implementation includes path normalization, heredoc handling, and wrapper command unwrapping to prevent bypasses.
crates/jcode-command-risk · high confidence
Introduce goal management data types
The \jcode-task-types\ crate now defines the core data structures for goal management, including \Goal\, \GoalStatus\, \GoalScope\, \GoalMilestone\, and \GoalStep\. This introduces a structured model for tracking goal progress, status transitions (such as Active, Blocked, Completed), and hierarchical breakdowns via milestones and steps, enabling downstream components to persist and query goal-oriented tasks.
crates/jcode-task-types · high confidence
Introduce graph-based memory storage with tagging, clustering, and cascade retrieval
The memory system now uses a graph structure to organize memories, enabling explicit organization via tags and automatic grouping into clusters. Users benefit from semantic linking between memories, allowing the system to retrieve related information through a breadth-first cascade traversal that scores and ranks results. The graph supports versioned storage (v2) and tracks various relationship types such as tags, semantic relevance, supersession, and contradictions, providing a richer context for memory recall and maintenance.
crates/jcode-memory-types · high confidence
Introduce harness API bridge with memory optimization and background progress support
The harness API server now includes a new bridge component that exposes a stable versioned API over a Unix socket (or named pipes on Windows), translating JSON requests to the legacy internal daemon protocol. This update adds a custom memory allocator configuration to limit glibc malloc arenas and trim freed heap pages, reducing memory usage for long-lived connections. It also introduces a parser for background task progress notifications, allowing API clients to display task labels, percentages, and completion status. Additionally, the bridge implements frame size limits to prevent unbounded memory allocation from malformed or large client inputs, and includes comprehensive tests for frame reading, background progress parsing, and stream translation.
crates/jcode-harness-api-server/src · high confidence
Introduce macOS desktop control tool
Added a new \macos\_computer\_use\ tool that allows the agent to see and control the macOS desktop. It provides visible coordinate input (mouse/keyboard) via Core Graphics, background UI control via Accessibility (pressing buttons, setting field values), and scripting via AppleScript/JXA. The tool includes actions for screenshots, OCR, window management, app control, clipboard, and system notifications, with a progressive disclosure schema to keep prompt costs low. It also handles permission setup and checks for Accessibility and Screen Recording grants.
crates/jcode-app-core/src/tool/computer · high confidence
Introduce opt-in Codemode: an embedded QuickJS sandbox for composing tool calls
Users can now enable Codemode, an opt-in feature that allows the model to write a short JavaScript program to orchestrate multiple tool calls in a single execution. This embedded QuickJS sandbox runs locally, keeping intermediate results private and only returning the final script output to the transcript. The sandbox provides a \tools\ proxy and \callTool\ function to invoke built-in and MCP tools, supports parallel execution, includes a persistent key-value store, and enforces strict resource limits (memory, timeout, and log size). Note that this feature is unavailable on FreeBSD builds due to missing QuickJS bindings.
crates/jcode-codemode · high confidence
Introduce self-development mode types and desktop repository detection
The \jcode-selfdev-types\ crate now provides the foundational types and utilities for a new self-development workflow. It introduces a \desktop\_repo\_root\ function that locates the Jcode Desktop checkout by scanning for the \jcode-desktop-ui\ directory and validating the \Cargo.toml\ package name, handling symlinks and nested paths. Additionally, it defines the \SelfDevBuildTarget\ enum (supporting \auto\, \tui\, and \all\ targets) and various data structures for managing canary builds, including \BuildInfo\, \CrashInfo\, \PendingActivation\, and \MigrationContext\, along with a \CLIENT\_SELFDEV\_ENV\ constant to signal self-dev mode to child processes.
crates/jcode-selfdev-types · high confidence
Introduce side panel state and payload types
The \jcode-side-panel-types\ crate now defines the core data structures for the side panel, including \SidePanelPageFormat\ (Markdown or PDF) and \SidePanelPageSource\ (Managed, LinkedFile, or Ephemeral). It introduces \SidePanelSnapshot\ to represent the current panel state with methods to check for pages and retrieve the focused page, alongside \PersistedSidePanelState\ and \PersistedSidePanelPage\ for saving and restoring panel history. The \SidePanelPage\ struct supports both Markdown content and optional Base64-encoded PDF data, enabling the display of bounded linked PDF payloads within the panel.
crates/jcode-side-panel-types · high confidence
Introduce stable harness API crate for external client integration
The new \jcode-harness-api\ crate provides a stable, versioned NDJSON-based interface for external clients (such as TUIs, desktop apps, or scripts) to interact with the agent runtime. It exposes a curated set of requests and streaming events, including session management (create, attach, fork, archive), message sending with image support, tool configuration, and real-time updates like text deltas, token usage, and KV cache misses. The crate also includes utilities for resolving the correct Unix socket path to ensure reliable connectivity and functions to enrich session lists with local edit statistics and swarm metadata.
crates/jcode-harness-api/src · high confidence
Introduce standalone harness API bridge daemon
A new standalone binary, jcode-harness-api-bridge, has been added to translate the versioned harness API socket onto the legacy daemon protocol. This bridge addresses performance and stability issues by limiting the Tokio runtime to two worker threads and eight blocking threads (with a 2-second keep-alive) to prevent excessive memory usage and thread churn. It also correctly handles --help and --version flags to avoid startup errors during preflight checks, and ensures that synchronous I/O operations do not block the accept loop, allowing new session handshakes to proceed without delay.
crates/jcode-harness-api-server/src/bin · high confidence
Introduces core swarm constants and validation logic
The \jcode-swarm-core\ crate now defines key constants for swarm behavior, including a maximum of 1000 live agents (\MAX\_SWARM\_MEMBERS\) and a 240-character threshold for requiring summaries (\SWARM\_TLDR\_REQUIRED\_OVER\_CHARS\). It provides a \validate\_swarm\_tldr\ function that automatically generates a truncated preview for long messages lacking a summary, ensuring delivery is never blocked by missing metadata. Additionally, it includes a \derive\_swarm\_task\_label\ helper to generate short, stable UI labels from spawn prompts and defines the \SwarmRole\ and \SwarmLifecycleStatus\ enums for serialization.
crates/jcode-swarm-core · high confidence
Introduces shared swarm plan state and reliable Mermaid graph rendering
The \jcode-plan\ crate now provides the core data structures and logic for swarm coordination, including a \VersionedPlan\ for durable, versioned state and a hard cap of 1,024 items to prevent unbounded growth. It also introduces a dedicated Mermaid module that generates task DAG visualizations, handling layout direction (top-down vs. left-right) and truncation to ensure the graph remains legible in terminal views.
crates/jcode-plan · high confidence
Introduces the jcode-applet-types crate for versioned, validated applet wire protocols
This change adds the \jcode-applet-types\ crate, which defines the structured wire types for declarative, sandboxed custom UI hosted by Jcode Desktop. It introduces a versioned schema (\jcode.applet/1\) and a comprehensive validation layer that enforces resource limits (such as node depth, text size, and image bytes) and capability gates (requiring explicit permissions for actions like opening URLs, accessing files, or rendering HTML). The crate provides the data models for applet manifests, runtime messages (including incremental JSON Patch updates), and a declarative view tree of native components. It also defines placement strategies (panels, sidebars, inline, overlays) and asset handling, ensuring that hosts can safely render provider-generated UI while degrading gracefully for unknown node types.
crates/jcode-applet-types · high confidence
New Azure authentication helper for retrieving bearer tokens
The \jcode-azure-auth\ crate now provides a \get\_bearer\_token\ function that uses the Azure Identity \DeveloperToolsCredential\ to acquire a bearer token for a specified scope, simplifying access to Azure services during local development.
crates/jcode-azure-auth · high confidence
New CLI commands for Jcode account management and Agent Client Protocol (ACP) adapter
The CLI now includes \jcode account\ commands (\login\, \status\, \manage\, \logout\) to handle Jcode subscription billing, allowing users to view their plan, usage, and manage credentials. Additionally, a new \jcode acp\ command exposes the Agent Client Protocol, enabling external tools to interact with the Jcode daemon via JSON-RPC, including model selection, token usage reporting, and session management.
src/cli · high confidence
New CLI commands for menubar status, provider setup, auth diagnostics, and session restart management
The CLI now includes four new command modules. The \menubar\ command provides a live macOS status bar indicator showing the count of running and streaming sessions, with \--once\ and \--json\ flags for scripting, and automatically manages a singleton helper process on macOS. The \provider\_setup\ command allows users to add and configure new provider profiles via the CLI, handling API keys, environment files, and auth modes. The \report\_info\ module introduces \auth-status\ and \auth-doctor\ commands to inspect provider authentication health, validate credentials, and surface recovery guidance. Finally, the \restart\ command enables saving and restoring session snapshots across reboots, with an optional auto-restore flag for seamless recovery.
src/cli/commands · high confidence
New OpenAI provider crate with streaming and request shaping
A new \jcode-provider-openai\ crate has been added to handle OpenAI API integration. It includes request shaping logic for the Responses API, specifically supporting deferred tool loading to preserve prompt cache and handling encrypted content size limits. The streaming module implements robust parsing for SSE events, ensuring tool names and inputs are emitted before arguments are complete, and correctly handles interleaved tool calls with stable identifiers. Additionally, a websocket health module manages transport fallbacks from websockets to HTTPS based on specific timeout and error conditions. Also in this area: Fix web search event timing and metadata preservation; Add diagnostic logging for OpenAI prompt cache hits and misses.
crates/jcode-provider-openai · high confidence
New Rust SDK for harness integration
A new Rust SDK (\jcode-sdk\) is available, mirroring the TypeScript SDK's capabilities to allow Rust-based clients to connect to the harness. It provides a \JcodeClient\ for managing sessions, streaming events, and handling tool calls, along with native OAuth login flows via \AuthClient\. The SDK also supports connecting to remote harnesses over system OpenSSH, launching isolated runtime instances, and includes diagnostics to explain connection failures in user-friendly terms. Also in this area: 1 commit (0 fixes) modifying crates/jcode-sdk; 1 commit (1 fix) fixing crates/jcode-app-core, crates/jcode-sdk; Secure credential storage and expanded SDK client types; User-created session collections and hidden per-turn reminders; Safer daemon cleanup on instance launch failure; and 2 more.
crates/jcode-sdk/src · medium confidence · unverified
New TUI account picker overlay for managing Anthropic and OpenAI accounts
The terminal UI now includes a dedicated account picker overlay that allows users to view, filter, and manage accounts for Anthropic and OpenAI providers. This new component supports switching active accounts, adding new credentials, logging in or refreshing existing sessions, removing saved accounts, and accessing provider settings. It features a searchable interface with categorized actions (switch, add, login, remove, settings) and displays usage summaries, helping users manage multiple identities directly within the terminal interface.
crates/jcode-tui-account-picker · high confidence
New TUI core library with streaming pacing, anchor stability, and keybinding support
The \jcode-tui-core\ crate has been introduced to centralize core TUI logic. It includes a \StreamBuffer\ that paces streaming text reveal to smooth out bursty provider responses (e.g., Anthropic), a \AnchorStabilityRecorder\ to quantify and report visual jarring in the transcript, and a \keybind\ module that normalizes keybindings across platforms (including macOS Option key support). Additionally, it provides \CopySelection\ types for managing selection state across chat, side pane, and input areas, and \graph\_topology\ utilities for building memory graph visualizations.
crates/jcode-tui-core · high confidence
New TUI style crate with configurable semantic colors and harmony scoring
The \jcode-tui-style\ crate introduces a fully user-configurable color system where every UI element is mapped to a semantic role (e.g., \user\, \ai\, \error\) that can be customized via \\~/.jcode/config.toml\. It includes an objective palette-harmony scoring engine that evaluates readability, distinctness, and colorblind safety, and can generate a complete harmonious palette from a single seed color. The module also handles terminal color capability detection, automatically quantizing to 256-color on macOS terminals with fragile glyph caches to prevent rendering artifacts, and adapts text contrast for light terminal themes.
crates/jcode-tui-style/src · high confidence
New TUI usage overlay for displaying API provider status
The \jcode-tui-usage-overlay\ crate introduces a new terminal UI component that displays a summary of API usage and limits from connected providers. Users can now view a color-coded status (healthy, warning, critical, error) for each provider, filter the list by text, and see detailed usage information in an interactive overlay panel.
crates/jcode-tui-usage-overlay · high confidence
New authentication status and credential tracking types
The \jcode-auth-types\ crate now provides a comprehensive set of enums and structs for representing authentication state, including \AuthState\ (Available, Expired, NotConfigured), \AuthCredentialSource\, \AuthExpiryConfidence\, \AuthRefreshSupport\, \AuthValidationMethod\, and \AuthReadinessLevel\, along with helper labels for logging. It also introduces \ProviderValidationRecord\ and \ProviderRefreshRecord\ to track provider health and refresh history, specifically adding a \rejected\_refresh\_fingerprint\ field to permanently skip retrying tokens that have been invalidly rejected, thereby avoiding unnecessary network retries on the critical path.
crates/jcode-auth-types · high confidence
New background task types and progress normalization logic
The \jcode-background-types\ crate introduces core data structures for background task management, including \BackgroundTaskStatus\, \BackgroundTaskProgress\, and specific events like \BackgroundTaskCompleted\ and \BackgroundTaskStalled\. A key behavioral addition is the \normalize\ method on progress updates, which ensures that measurable work counts (current/total) override conflicting reported percentages to prevent contradictory UI states. It also enforces progress clamping (0-100%) and automatically switches tasks from indeterminate to determinate progress when specific counts are provided. Additionally, helper functions are added to format these progress updates into human-readable displays with source labels (reported, parsed, estimated).
crates/jcode-background-types · high confidence
New batch progress data types for tracking sub-call states
A new \jcode-batch-types\ crate has been introduced to define the data structures used for reporting batch operation progress. This includes \BatchProgress\ and \BatchSubcallProgress\ structs, along with the \BatchSubcallState\ enum, which allow the system to expose detailed status updates such as running, succeeded, or failed states for individual sub-calls within a larger batch tool execution. These types enable richer UI rendering and more granular tracking of batch completion.
crates/jcode-batch-types · high confidence
New browser-backed ChatGPT web model route and extracted OpenAI provider runtime
Users can now select the \gpt-5.6-pro\[web\]\ model, which routes requests through a local Firefox browser instance to interact with ChatGPT using the user's active web session. This capability is supported by a new \jcode-provider-openai-runtime\ crate that extracts the OpenAI provider logic from \jcode-base\ to improve build times, and includes a persistent WebSocket implementation with prewarming, idle keepalive, and healthchecks to reduce cold-start latency. The runtime also features structured formatting for rate-limit errors and tracks ChatGPT OAuth usage by account. Also in this area: Recover from specific OpenAI WebSocket rejections via HTTPS fallback; Improved WebSocket cache affinity and diagnostic logging for OpenAI continuations; Safe recovery of OpenAI WebSocket connections after interrupted responses; Fixes for OpenAI stream stalls, WebSocket keepalive deadlocks, and OAuth rotation safety; Expanded test coverage for OpenAI runtime stability and behavior.
crates/jcode-provider-openai-runtime · high confidence
New build-support crate for self-dev and update management
A new \jcode-build-support\ crate has been added to centralize build-time and runtime support logic. It introduces a \BuildManifest\ to track stable, canary, and crash states, and provides path resolution helpers for binaries, symlinks, and version files. The crate includes platform-specific logic for atomic launcher swaps on Windows and Unix, source-state fingerprinting to detect tree drift, and a process-local cache for build progress to reduce disk I/O during TUI updates.
crates/jcode-build-support/src · high confidence
New dedicated permissions dialog UI in the TUI
A new \jcode-tui-permissions\ crate has been introduced to handle permission requests within the terminal user interface. This change extracts the permissions dialog logic into a standalone component, providing a dedicated screen where users can view pending permission requests, review their urgency levels (high, normal, low), and approve or deny them individually or in bulk. The UI displays request details, timestamps, and action hints, recording the user's decisions via file-based persistence.
crates/jcode-tui-permissions · high confidence
New desktop-open crate for opening URLs and files via the companion
The new \jcode-desktop-open\ crate provides the shared logic for opening URLs and revealing local files using the desktop environment's native tools. It is owned by the jcode companion process, ensuring that the headless server never directly opens windows on the wrong machine. The implementation handles platform-specific openers (macOS \open\, Windows \explorer.exe\, and Unix fallbacks) and includes logic to focus the newly opened browser window after a URL is launched.
crates/jcode-desktop-open · high confidence
New diagnostic and benchmark binaries for tool, memory, and TUI performance
Added several new command-line binaries in src/bin to help users and developers verify tool correctness and measure performance. The \jcode-harness\ binary runs a deterministic smoke test of core file and shell tools (write, read, edit, patch, bash, etc.) against a temporary workspace. The \memory\_recall\_bench\ binary provides an offline benchmark for memory retrieval accuracy using real embedding models and graph data. The \session\_memory\_bench\ binary profiles the memory footprint of heavy sessions, comparing local versus duplicated provider states. The \tui\_bench\ binary measures TUI rendering performance, including side-panel markdown/mermaid rendering and policy-based redraw limits. Finally, \mermaid\_side\_panel\_probe\ allows probing mermaid diagram rendering metrics in the side panel, and \test\_api\ provides a quick smoke test for the Anthropic provider integration.
src/bin · high confidence
New diagnostic and benchmarking scripts for agent tracing, memory analysis, and model coverage
The scripts directory now includes several new tools to help users and developers analyze agent behavior and performance. The \agent\_trace.sh\ script provides a simple way to run a single agent prompt with tracing enabled for debugging. Python scripts \analyze\_openai\_ws\_cache.py\, \analyze\_root\_crate.py\, and \analyze\_runtime\_memory\_log.py\ offer deep-dive analysis into OpenAI WebSocket cache efficiency, Rust crate coupling for refactoring planning, and runtime memory usage spikes respectively. Additionally, \antigravity\_live\_coverage.sh\ and \antigravity\_multiturn\_coverage.sh\ allow users to smoke-test and validate multi-turn context retention for various Antigravity-backed models, while \antigravity\_schema\_probe.sh\ helps diagnose JSON schema compatibility issues. Finally, \attribution\_benchmark\_sponsors.json\ and \audit\_terminal\_bench\_submission.py\ support benchmarking sponsor attribution and auditing Terminal-Bench campaign submissions.
scripts · high confidence
New jcode-terminal-image crate for terminal image display
A new \jcode-terminal-image\ crate has been introduced to provide low-level primitives for rendering images in the terminal. It supports the Kitty graphics protocol, Sixel graphics, and iTerm2 inline images, with automatic detection of the best available protocol based on environment variables and terminal capabilities. By default, iTerm2 inline images are disabled to prevent output corruption in real iTerm2 sessions; users can opt in by setting the \JCODE\_ITERM2\_IMAGES=1\ environment variable. The crate also includes utilities for formatting image metadata (dimensions, byte counts, aspect ratios) and falls back to a simple placeholder if no image protocol is supported.
crates/jcode-terminal-image · high confidence
New pelican bicycle animation demo
Added a new interactive demo in the pelican-bike location featuring a looping canvas animation of a pelican riding a bicycle by the sea. The entry includes the HTML structure, CSS styling with responsive typography and paper-grain effects, and the JavaScript logic for the animated scene, providing users with a visual showcase of the animation capabilities.
assets/demos/pelican-bike · high confidence
New productivity report with shareable dashboard
A new \jcode-productivity-core\ crate now scans local session transcripts to generate a comprehensive usage report. The report aggregates metrics such as session counts, token usage, tool calls, and active days, and includes derived insights like streaks, peak hours, and a 'power score' with an archetype. Users can view the report as a formatted Markdown transcript or as a dark-themed, 'wrapped-style' PNG dashboard image saved to disk, which is suitable for sharing.
crates/jcode-productivity-core · high confidence
New protocol definitions for agent notifications and feature toggles
The protocol layer now includes structured definitions for inter-agent notifications, supporting file conflicts, shared context, and direct messages (with optional TLDR summaries for UI collapsing). It also introduces a runtime feature toggle system allowing sessions to enable or disable capabilities like Memory, Swarm, Autoreview, and Autojudge.
crates/jcode-base/src/protocol · high confidence
New provider-doctor diagnostic crate for end-to-end provider health checks
The \jcode-provider-doctor\ crate has been introduced to provide a dedicated, user-facing diagnostic tool for validating provider and model connectivity. It implements a three-tier verification system—Offline, Catalog, and Full—that allows users to isolate issues ranging from local configuration wiring to live API authentication and functional model usage (including chat, streaming, and tool calls). This new location for the doctor cluster ensures that updates to provider diagnostics no longer trigger rebuilds of the core application spine, while also exposing specific native runtime probes for providers like Anthropic and Antigravity to ensure the exact production code paths are exercised during health checks.
crates/jcode-provider-doctor · high confidence
New remote verification tools and documentation for cross-machine jcode sessions
Added \scripts/remote/remote\_check.py\ and \scripts/remote/gateway\_client.py\ to validate and drive jcode sessions on remote hosts via the WebSocket gateway, including pairing, token caching, and end-to-end health checks. Updated \scripts/remote/README.md\ to document the setup process, highlighting the \/remote\ commands for enabling the gateway and pairing, as well as practical gotchas like Windows Firewall behavior and network scoping.
scripts/remote · high confidence
New session data types and session title generation
The \jcode-session-types\ crate now defines core data structures for session management, including \ResumeTarget\ to support resuming sessions from external agents like Cursor, Claude Code, and Codex. It introduces \ResponseStats\ to expose per-turn usage metrics (tokens, duration) and \RenderedImage\ with anchoring logic to ensure images are displayed inline at their correct transcript position rather than appended at the end. Additionally, the crate provides \prompt\_title\ to automatically generate session titles from the first user prompt, ensuring sessions are named meaningfully instead of showing as 'New session'.
crates/jcode-session-types · high confidence
New storage crate for session presence, streaming state, and Windows credential hardening
The new \jcode-storage\ crate centralizes low-level filesystem state management for session presence and Windows security. It introduces \active\_pids\ and \streaming\_pids\ directories to track session ownership and active model generation, enabling the menubar to display accurate, real-time session counts and streaming indicators while filtering out internal debug sessions. It also adds a deferred, cached ACL hardening mechanism for Windows secrets to improve startup performance and reliability, and provides a \durable\_state\_dir\ to ensure swarm state persists across reboots.
crates/jcode-storage · high confidence
New swarm gallery rendering examples for live and preview demos
Added two new examples in \crates/jcode-tui-render/examples\ to visualize the swarm gallery layout: \swarm\_gallery\_live.rs\ provides an interactive, animated demo with mock workers streaming output and changing status, while \swarm\_gallery\_preview.rs\ offers a static visual preview of various swarm rendering modes (gallery, panel, compact strip) against mock data. These examples allow users to see how the inline swarm gallery, list+detail panel, and compact strip layouts appear in the TUI without needing to run actual agents.
crates/jcode-tui-render/examples · high confidence
New terminal login prompt with masked secret input and Unicode QR codes
The \jcode-terminal-prompt\ crate now provides the interactive login UI for the CLI, introducing two key capabilities: masked secret entry and Unicode QR code rendering. For secret inputs (such as API keys or verification codes), the terminal now operates in raw mode to echo a \\*\ for each keystroke, ensuring credentials are never displayed on screen while providing visible feedback to prevent the prompt from appearing hung. Additionally, login QR codes are rendered using Unicode half-block glyphs (without ANSI escape codes) and are displayed automatically when browser-based login is suppressed, or optionally via environment variables (\JCODE\_SHOW\_LOGIN\_QR\, \JCODE\_TUI\_LOGIN\_QR\).
crates/jcode-terminal-prompt · high confidence
New usage and telemetry type definitions for provider limits and tool categorization
The \jcode-usage-types\ crate now defines core data structures for tracking provider usage and telemetry. This includes \OpenAiResetCredits\ and \AnthropicLimitResetOffer\ to expose session-limit reset metadata and credit expirations to clients, as well as \ProviderUsage\ and \ProviderUsageProgress\ for reporting usage limits and recency. Additionally, it introduces \TelemetryToolCategory\ with a classification function for tools (e.g., ReadSearch, Write, Shell, Todo) and \TelemetryWorkflowCounts/Flags\ to aggregate workflow metrics like file writes, tests, and feature usage.
crates/jcode-usage-types · high confidence
New visual debug infrastructure for TUI frame capture
A new \jcode-tui-visual-debug\ crate has been introduced to support autonomous debugging of the terminal user interface. This component captures detailed TUI frame states—including layout areas, widget placements, render timing, and state snapshots—and writes them to a debug file. This allows users or AI agents to diagnose visual bugs by analyzing the structured render data without needing to view the live terminal output.
crates/jcode-tui-visual-debug · high confidence
OpenRouter runtime extracted to dedicated crate with Ollama context and catalog fixes
The OpenRouter provider runtime has been moved from the base crate into a new standalone crate, \jcode-provider-openrouter-runtime\, to speed up compilation when editing provider code. This extraction includes several critical fixes: Ollama models now correctly report their actual serving context window by probing the native API, preventing silent truncation and lost conversation history; the model catalog merge logic now preserves user-declared models even after a live catalog refresh; and a deadlock in the pricing lookup on cold catalogs is resolved. Additionally, the runtime now respects input modalities declared in the model catalog for image support and includes comprehensive tests for these behaviors.
crates/jcode-provider-openrouter-runtime · high confidence
Replace per-provider deny-lists with a configurable schema dialect system
The \jcode-schema-dialect\ crate introduces a new system for handling provider-specific JSON Schema constraints, replacing the previous ad-hoc deny-lists with a structured dialect approach. This system uses allow-lists to define which keywords each provider (OpenAI, Gemini, Anthropic, etc.) accepts, automatically stripping unsupported constructs to prevent 400 errors. It also includes structural transformations (like flattening combiners or pruning dangling required fields) and a recovery layer that learns from runtime rejections, persisting quirks to avoid repeated failures. This ensures that unknown or unsupported schema features are handled gracefully without breaking tool execution.
crates/jcode-schema-dialect · high confidence
Reserved 'jcode' name on crates.io with a placeholder package
A new placeholder package named 'jcode' has been added to crates.io to reserve the name. When users attempt to install this specific crate, the program prints an error message directing them to the official installation methods (curl, PowerShell, or Homebrew) and the documentation site, then exits with a non-zero status. This prevents accidental installation of a non-functional package and guides users to the correct distribution channels.
packaging/crates-io-placeholder · high confidence
Sponsor discovery provenance tagging and coarse usage metering
The system now tracks which MCP servers are connected via sponsor discovery listings and aggregates coarse usage metrics (connects, calls, and errors) per sponsor per day. This data is flushed hourly to the configured sponsor endpoint, strictly excluding user content, arguments, or identity, and only operates when the sponsors feature is enabled.
crates/jcode-base/src/sponsors · high confidence
Stall watchdog detects and reports silent session hangs
The jcode-logging crate now includes a stall watchdog that monitors for silent freezes during long-running sessions. When the process stops making progress while work is in flight, it logs a 'watchdog.stall' event containing the last active phase, a per-thread state snapshot (to distinguish deadlocks from blocked I/O), and resource metrics. The watchdog only reports stalls when actual work is in progress, preventing false positives during idle waits for user input. This helps users identify and diagnose hangs that previously left logs ending abruptly with no explanation.
crates/jcode-logging · high confidence
System messages now render markdown formatting and preserve layout
System messages in the TUI now support markdown formatting, meaning inline markers for bold, code, headings, and links are processed and rendered as styled text rather than appearing as raw syntax. Additionally, the rendering logic now preserves indentation and newlines within these messages, and ensures that all spans retain the designated system message color. This change is accompanied by a new test suite in \ui\_messages/tests.rs\ that verifies these rendering behaviors, including single-line wrapping for cold-cache and launch hotkey notices. Also in this area: 17 commits (0 fixes) modifying crates/jcode-tui; Cloud session replacement and swarm status visibility; Todo completion reports now use compact detail rows instead of full Markdown; Info widgets display specific metadata in footers instead of generic labels.
_crates/jcode-tui/src/tui/ui\messages · medium confidence · unverified
Telemetry worker schema and dashboard expansion
The telemetry-worker now captures significantly richer usage data through a series of database migrations (0001–0010) that add columns for transport metrics, detailed session timing, per-turn analytics, token usage, and agent-time attribution. To support this, new SQL dashboard queries have been introduced for concurrency tracking, website-to-install conversion funnels, geographic distribution, and health monitoring, alongside a new README documenting the dual-write architecture (Analytics Engine and D1) and D1 size self-defense mechanisms. Also in this area: 10 commits (7 fixes) fixing telemetry-worker; Automated nightly price syncing and pre-release family estimates for new models; Desktop fleet telemetry support for active installs and update outcomes.
(repo-wide) · medium confidence
Usage reporting now covers all login methods and API keys
The /usage command and usage widget now display quota and spending details for Anthropic OAuth, OpenAI/Codex OAuth, and configured API keys (including OpenAI-compatible profiles like DeepSeek, Kimi, and Z.ai). The system also tracks Anthropic session-limit reset offers and provides account-scoped usage snapshots for multi-account setups.
crates/jcode-base/src/usage · high confidence
iOS UX reward framework and UI quality analysis tools
Added a new iOS TestHarness reward framework that quantifies user experience through an interaction-cost engine (modeling user behavior as a Markov chain to calculate expected action times in seconds) and a design-system linter that enforces source-code discipline by checking for hardcoded colors, fonts, and spacing values. The harness also includes a UI efficiency analyzer that scores rendered screenshots on space usage, consistency, legibility, and rhythm, alongside scripts to analyze runtime memory logs and benchmark CLI startup and memory usage.
python · high confidence
Removals
Removal of legacy Claude and Codex credential loaders
The authentication module no longer includes support for loading credentials from the legacy Claude CLI (\.claude/.credentials.json\) or the Codex CLI (\.codex/auth.json\). These specific credential-loading implementations have been removed from the codebase, meaning users can no longer automatically import or reuse authentication tokens from these external tools within this authentication subsystem.
src/auth · high confidence
Removal of legacy Claude and OpenAI provider implementations
The legacy direct API implementations for the Claude and OpenAI providers have been removed from the codebase. This change eliminates the previous HTTP-based streaming logic and message serialization for these backends, reflecting a shift away from these specific transport methods in favor of newer provider integrations.
src/provider · high confidence
Removed legacy file and shell manipulation tools
The \bash\, \edit\, \glob\, \grep\, \read\, and \write\ tools have been removed from the tool registry in \src/tool\. This eliminates the previous implementations for executing shell commands, performing text replacements, searching files, and reading/writing file contents, indicating a shift away from these specific legacy capabilities in the current toolset.
src/tool · high confidence
Architecture
Extracted and formalized the client-server protocol into a dedicated crate
The client-server communication logic has been extracted into the new \jcode-protocol\ crate, establishing a stable, self-describing wire format for all client-server interactions. This change introduces structured types for session tool configuration and task-DAG node specifications, enabling SDK-owned session tools and explicit task graph operations. It also formalizes the message protocol with support for context-only message injection (no-reply), soft interrupts with image attachment preservation, and remote session rewind/undo capabilities. The protocol now exposes detailed memory pipeline snapshots for observability, typed authentication change events, and feature toggles for capabilities like swarm and memory, ensuring that clients and the server share a consistent contract for state, notifications, and control flows.
crates/jcode-protocol/src · high confidence
Extracted provider metadata into a dedicated catalog crate
The provider metadata (login providers, OpenAI-compatible profiles, and their configuration) has been extracted into the new \jcode-provider-metadata\ crate. This centralizes definitions for authentication methods (OAuth, API key, CLI, etc.) and surfaces (CLI, TUI, server bootstrap, auto-init), making it easier to manage and extend provider support without touching core logic.
crates/jcode-provider-metadata · high confidence
Extracted shared TUI rendering utilities and swarm gallery layout
The \jcode-tui-render\ crate now provides a centralized library for terminal UI components, extracting previously scattered logic into dedicated modules. This includes \chrome.rs\ for common UI elements like right-rail borders and content alignment, \layout.rs\ for rectangle geometry helpers, and \memory\_tiles.rs\ for parsing and displaying memory entries. Crucially, it introduces \swarm\_gallery.rs\ and \swarm\_tiles.rs\, which define the shared presentation logic and grid layout for the swarm agent gallery, ensuring consistent rendering of agent status glyphs, role indicators, and viewport cells across both the live TUI and demo environments.
crates/jcode-tui-render/src · high confidence
Extracted terminal UI and video export into a dedicated jcode-tui crate
The terminal presentation layer and offline replay export functionality have been moved from the monolithic root crate into a new, separate \jcode-tui\ crate. This change isolates the \tui\ and \video\_export\ modules, allowing them to compile as an independent rustc unit while re-exporting the application core (\jcode-app-core\) to maintain existing internal module paths. The crate now explicitly manages the rendering of swarm-replay panes into video frames and handles system notice rendering as plaintext.
crates/jcode-tui/src · high confidence
Gemini provider runtime extracted to standalone crate
The Gemini provider implementation has been moved from the \jcode-base\ crate into a new, separate crate (\jcode-provider-gemini-runtime\). This architectural change allows the Gemini provider to be compiled and updated independently of the core application spine, reducing build times and isolation for provider-specific logic. The new crate exposes the \GeminiProvider\ and re-exports necessary Gemini types, while the application's composition root now registers this provider via \jcode\_base::provider::external\.
crates/jcode-provider-gemini-runtime/src · high confidence
Major architectural refactor and allocator tuning
The application has been restructured into a multi-crate architecture (jcode-app-core, jcode-tui, jcode-base) with the root src/lib.rs now acting as a facade that re-exports the presentation and core layers, while the monolithic src/main.rs has been replaced by a sophisticated entry point. This new entry point handles platform-specific startup logic, including a larger stack size for Windows to prevent overflow, macOS hotkey listener initialization on the main thread, and Linux system allocator tuning (mallopt) to reduce RSS memory usage. Additionally, optional jemalloc support has been added with specific configuration for long-running server workloads, and the previous standalone agent REPL has been removed in favor of the new server/client TUI architecture.
src · high confidence
Provider runtime implementations moved to downstream crates
The provider runtime implementations (e.g., Anthropic, OpenAI, Gemini, Copilot, Cursor, Antigravity, Bedrock) have been extracted from \jcode-base\ into separate downstream crates. \jcode-base\ now acts as a composition root and compatibility shim, holding only the pure model-catalog data, credential probes, and routing logic needed by the provider layer. This architectural change ensures that editing a specific provider no longer triggers a full rebuild of the base -\> app-core -\> TUI spine, significantly improving build times and modularity.
crates/jcode-base/src/provider · high confidence
TUI presentation layer extracted into jcode-tui crate
The TUI presentation logic has been refactored into a dedicated \jcode-tui\ crate, separating it from the core application logic. This change introduces a modular structure with new modules for account picking, fuzzy matching, and info widgets (commits, layout, frame), while consolidating shared state and helper functions in \core.rs\ and \backend.rs\. The extraction improves code organization and maintainability for the terminal user interface.
crates/jcode-tui/src/tui · high confidence
Behavioural changes
1 commit (0 fixes) modifying assets/macos-notifier
A change to existing behaviour in assets/macos-notifier — 1 commit, 1 file: “feat(macos): notifier app bundle plus automated notification-click validator”.
assets/macos-notifier · medium confidence · unverified
1 commit (0 fixes) modifying crates/jcode-tui/src/bin
A change to existing behaviour in crates/jcode-tui/src/bin — 1 commit, 1 file: “refactor(video): isolate replay exporter from root CLI compilation”.
crates/jcode-tui/src/bin · medium confidence · unverified
1 commit (0 fixes) modifying crates/jcode-tui/src/tui/ui\_pinned, crates/jcode-tui/src/tui/ui\_tests/prepare, crates/jcode-tui/src/tui/ui\_todo\_stages\_tests
A change to existing behaviour in crates/jcode-tui/src/tui/ui\_pinned, crates/jcode-tui/src/tui/ui\_tests/prepare, crates/jcode-tui/src/tui/ui\_todo\_stages\_tests — 1 commit, 3 files: “refactor(tui): extract cohesive modules to satisfy size ratchets”.
_crates/jcode-tui/src/tui/ui\_pinned, crates/jcode-tui/src/tui/ui\_tests/prepare, crates/jcode-tui/src/tui/ui\_todo\_stages\tests · medium confidence · unverified
11 commits (5 fixes) modifying crates/jcode-base/src/auth/oauth\_tests
A change to existing behaviour in crates/jcode-base/src/auth/oauth\_tests — 11 commits (5 fixs), 5 files: “feat(login): OpenAI device-code sign-in (--device-code) for remote and cloud machines”; “Persist Claude subscription metadata from OAuth profiles”; “fix(windows): harden credential paths without walking descendants (refs \#2061)”; and 8 more (refs \#2061).
_crates/jcode-base/src/auth/oauth\tests · medium confidence · unverified
11 commits (5 fixes) modifying crates/jcode-build-meta
A change to existing behaviour in crates/jcode-build-meta — 11 commits (5 fixs), 2 files: “fix: preserve dev version offset in hosted builds”; “fix(clippy): collapse nested if in build-meta version parser”; “fix: tolerate prerelease build identities (fixes \#2042)”; and 8 more (refs \#2042).
crates/jcode-build-meta · medium confidence · unverified
13 commits (2 fixes) modifying crates/jcode-tui/src/tui/session\_picker\_tests
A change to existing behaviour in crates/jcode-tui/src/tui/session\_picker\_tests — 13 commits (2 fixs), 5 files: “Improve usage snapshots, session picker mobile inventory, and cloud transport”; “Decouple resume query editing from all search matching”; “fix(resume): rank fork-local requests above incidental title matches”; and 10 more.
_crates/jcode-tui/src/tui/session\_picker\tests · medium confidence · unverified
14 commits (5 fixes) modifying crates/jcode-voice
A change to existing behaviour in crates/jcode-voice — 14 commits (5 fixs), 16 files: “fix: report client focus and voice background failures”; “refactor: restore owned Rust budgets and handle runtime errors”; “feat(companion): jcode companion owns desktop effects; server asks it to open, spawn terminals and hold the lid”; and 10 more.
crates/jcode-voice · medium confidence · unverified
15 commits (4 fixes) modifying crates/jcode-tui/src/tui/ui\_input
A change to existing behaviour in crates/jcode-tui/src/tui/ui\_input — 15 commits (4 fixs), 2 files: “Restore compact comprehensive TUI activity status”; “Show original and current session directories in overscroll”; “refactor(tui): bound rendering modules and preserve CLI helper contracts”; and 12 more.
_crates/jcode-tui/src/tui/ui\input · medium confidence · unverified
16 commits (4 fixes) modifying crates/jcode-tui/src/tui/session\_picker/transcript\_search
A change to existing behaviour in crates/jcode-tui/src/tui/session\_picker/transcript\_search — 16 commits (4 fixs), 5 files: “Weight /resume project name and working directory above IDs and tool input”; “fix(tui): handle runtime failures without panic or silent defaults”; “Bound incremental search evidence overhead and document readiness gains”; and 13 more.
_crates/jcode-tui/src/tui/session\_picker/transcript\search · medium confidence · unverified
16 commits (6 fixes) modifying crates/jcode-protocol/src/wire
A change to existing behaviour in crates/jcode-protocol/src/wire — 16 commits (6 fixs), 1 file: “refactor: restore owned Rust budgets and handle runtime errors”; “fix(usage): fetch account router quotas on daemon in background”; “Fence resumed observer events by runtime generation and turn identity”; and 13 more.
crates/jcode-protocol/src/wire · medium confidence · unverified
16 commits (7 fixes) modifying telemetry-worker/scripts
A change to existing behaviour in telemetry-worker/scripts — 16 commits (7 fixs), 5 files: “fix(telemetry): price new models nightly so spend stops reading $0 for Opus 5.5”; “fix(telemetry): back off operator cleanup on D1 overload”; “chore(telemetry): point dashboards at bulk DB where data moved”; and 10 more.
telemetry-worker/scripts · medium confidence · unverified
164 commits (26 fixes) modifying crates/jcode-tui/src/tui/session\_picker
A change to existing behaviour in crates/jcode-tui/src/tui/session\_picker — 164 commits (26 fixs), 37 files: “Weight /resume project name and working directory above IDs and tool input”; “feat(tui): add onboarding architecture review action”; “feat(resume): highlight search matches in session picker rows”; and 156 more (refs \#674, \#2063).
_crates/jcode-tui/src/tui/session\picker · medium confidence · unverified
19 commits (8 fixes) modifying crates/jcode-tui/src/tui/ui\_prepare
A change to existing behaviour in crates/jcode-tui/src/tui/ui\_prepare — 19 commits (8 fixs), 5 files: “refactor(tui): bound rendering modules and preserve CLI helper contracts”; “fix(tui): invalidate prepared caches for compact thinking”; “Honor link URL display options in core adapter and expose source link hit testing”; and 14 more (refs \#344).
_crates/jcode-tui/src/tui/ui\prepare · medium confidence · unverified
2 commits (1 fix) modifying assets/app-icons
A change to existing behaviour in assets/app-icons — 2 commits (1 fix), 1 file: “Add donut icon to macOS launcher app”; “macos: hide notification helper, drop CLI Spotlight launcher; rustfmt fixes”.
assets/app-icons · medium confidence · unverified
2 commits (1 fix) modifying crates/jcode-docs-data
A change to existing behaviour in crates/jcode-docs-data — 2 commits (1 fix), 2 files: “Keep bundled documentation out of the application rebuild graph”; “fix(policy): handle durable state failures and remove rendering panics”.
crates/jcode-docs-data · medium confidence · unverified
2 commits (1 fix) modifying scripts/waybar
A change to existing behaviour in scripts/waybar — 2 commits (1 fix), 4 files: “fix(waybar): discover session sockets with directory watches”; “feat(waybar): show cloud streaming and live agent counts”.
scripts/waybar · medium confidence · unverified
3 commits (0 fixes) modifying crates/jcode-tui/src/tui/ui\_viewport
A change to existing behaviour in crates/jcode-tui/src/tui/ui\_viewport — 3 commits, 1 file: “refactor(tui): extract cohesive modules to satisfy size ratchets”; “Remove built-in remote compilation and normalize Rust formatting”; “ratatui-jcode: skip already-empty cells on reset/clear, in-place set\_symbol; tui: getrusage frame CPU sample, memoized prompt preview”.
_crates/jcode-tui/src/tui/ui\viewport · medium confidence · unverified
30 commits (11 fixes) modifying crates/jcode-tui/src/tui/ui\_header
A change to existing behaviour in crates/jcode-tui/src/tui/ui\_header — 30 commits (11 fixs), 2 files: “tui: show no auto-routing accounts hint as plain text”; “Keep account identity and usage limits on one compact header row”; “Improve usage snapshots, session picker mobile inventory, and cloud transport”; and 27 more (refs \#1907).
_crates/jcode-tui/src/tui/ui\header · medium confidence · unverified
37 commits (8 fixes) modifying crates/jcode-todo-policy
A change to existing behaviour in crates/jcode-todo-policy — 37 commits (8 fixs), 11 files: “fix: name spawned lane todo from the lane label, keep names unique (fixes \#2151)”; “fix(todo): disable legacy quality follow-ups unless explicitly enabled”; “Move auto-poke and todo quality gates into a shared SDK policy”; and 34 more (refs \#2151).
crates/jcode-todo-policy · medium confidence · unverified
5 commits (1 fix) modifying vendor/ratatui-jcode/ratatui-widgets
A change to existing behaviour in vendor/ratatui-jcode/ratatui-widgets — 5 commits (1 fix), 35 files: “fix(ci): resolve remaining ratatui widget lint failures”; “ratatui-jcode: row-slice Buffer::set\_style (no-op for default style) and Paragraph render\_line”; “ratatui-jcode: single-measure LineTruncator, report flushed cell updates; drop jcode's duplicate cell compare”; and 2 more.
vendor/ratatui-jcode/ratatui-widgets · medium confidence · unverified
6 commits (1 fix) modifying crates/jcode-base/src/session/render
A change to existing behaviour in crates/jcode-base/src/session/render — 6 commits (1 fix), 2 files: “feat(sdk): expose durable per-turn history response stats”; “Preserve tool execution duration in live and restored rows”; “Track per-request cache prompt totals across providers and history”; and 2 more.
crates/jcode-base/src/session/render · medium confidence · unverified
6 commits (2 fixes) modifying src/cli/acp
A change to existing behaviour in src/cli/acp — 6 commits (2 fixs), 2 files: “refactor: restore owned Rust budgets and handle runtime errors”; “swarm: remove task graph and swarm-deep; swarm mode appends a user-message reminder”; “ACP: report max\_tokens/max\_turn\_requests/refusal/cancelled stop reasons and scope cancellation to the active prompt (\#2094)”; and 3 more (refs \#2094, \#2075).
src/cli/acp · medium confidence · unverified
6 commits (2 fixes) modifying src/cli/cloud\_move
A change to existing behaviour in src/cli/cloud\_move — 6 commits (2 fixs), 3 files: “Trace cloud resume latency stages and report slow operations”; “Improve usage snapshots, session picker mobile inventory, and cloud transport”; “Fix CI: collapse clippy if, refresh size/safety budgets, include pending history changes”; and 3 more.
_src/cli/cloud\move · medium confidence · unverified
7 commits (3 fixes) modifying crates/jcode-build-meta/src
A change to existing behaviour in crates/jcode-build-meta/src — 7 commits (3 fixs), 1 file: “fix: preserve dev version offset in hosted builds”; “fix: tolerate prerelease build identities (fixes \#2042)”; “refactor(build): centralize JCODE\\ version metadata into jcode-build-meta crate”; and 4 more (refs \#2042).
crates/jcode-build-meta/src · medium confidence · unverified
8 commits (1 fix) modifying crates/jcode-tui/src/tui/session\_picker/loading
A change to existing behaviour in crates/jcode-tui/src/tui/session\_picker/loading — 8 commits (1 fix), 3 files: “Improve usage snapshots, session picker mobile inventory, and cloud transport”; “Discover mobile-created cloud sessions in local resume picker”; “refactor(tui): extract cohesive modules to satisfy size ratchets”; and 5 more.
_crates/jcode-tui/src/tui/session\picker/loading · medium confidence · unverified
9 commits (1 fix) modifying crates/jcode-tui/src/tui/session\_picker/cloud\_preview
A change to existing behaviour in crates/jcode-tui/src/tui/session\_picker/cloud\_preview — 9 commits (1 fix), 3 files: “fix(tui): make preview fallback failures observable and panic-free”; “Scope cloud preview cache by API endpoint and record live projection timings”; “Bound cloud previews remotely and stream inventory metadata”; and 6 more.
_crates/jcode-tui/src/tui/session\_picker/cloud\preview · medium confidence · unverified
9 commits (1 fix) modifying vendor/ratatui-jcode/ratatui-core
A change to existing behaviour in vendor/ratatui-jcode/ratatui-core — 9 commits (1 fix), 54 files: “ratatui-jcode: row-slice Buffer::set\_style (no-op for default style) and Paragraph render\_line”; “fix(ci): clear ratatui preview clippy blockers”; “ratatui-jcode: ASCII width/grapheme fast paths, single-measure diff, cheap-first Cell eq; run upstream tests in workspace”; and 6 more.
vendor/ratatui-jcode/ratatui-core · medium confidence · unverified
9 commits (3 fixes) modifying crates/jcode-companion
A change to existing behaviour in crates/jcode-companion — 9 commits (3 fixs), 4 files: “fix: report client focus and voice background failures”; “refactor: restore owned Rust budgets and handle runtime errors”; “feat(companion): jcode companion owns desktop effects; server asks it to open, spawn terminals and hold the lid”; and 6 more (refs \#2080).
crates/jcode-companion · medium confidence · unverified
95 commits (37 fixes) modifying crates/jcode-base/src/session
A change to existing behaviour in crates/jcode-base/src/session — 95 commits (37 fixs), 15 files: “perf(session): journal entries no longer repeat unchanged compaction state”; “Show original and current session directories in overscroll”; “config: expose swarm/agent settings via default file, /config, and env overrides”; and 77 more (refs \#1694, \#1680, \#1712, \#1632, \#842, …).
crates/jcode-base/src/session · medium confidence · unverified
Background task management and status tracking
The background task subsystem now persists detailed status files to disk, including owner process identification (PID and instance token) to correctly reconcile tasks across server reloads and crashes. Progress updates are serialized and validated, and a watchdog mechanism stalls and wakes the agent if a background task goes quiet, ensuring reliable completion and UI feedback. Also in this area: 4 commits (0 fixes) modifying crates/jcode-base; Improved reliability of background task cancellation and status updates.
crates/jcode-base/src/background · medium confidence · unverified
Centralized provider core with robust retry, auth, and fallback logic
The \jcode-provider-core\ crate now centralizes provider logic, introducing structured handling for dual-auth providers (Anthropic and OpenAI) via a unified \AuthRoute\ that resolves OAuth vs. API-key credentials from various input formats. It adds a sophisticated retry mechanism using \AttemptGuard\ to track and rollback streamed output during transient transport errors, preventing duplicate content. The module also provides a deterministic fallback picker that suggests the best alternative model route (prioritizing same-model OAuth switches) when the current route fails, and implements a failover classifier to automatically route context-length or rate-limit errors to alternative providers.
crates/jcode-provider-core · high confidence
Centralized tool schema injection for intent and large-output handling
The tool core now automatically injects an 'intent' parameter (required) and an 'accept\_large\_output' escape hatch (optional) into every tool's JSON schema via the \ensure\_intent\_in\_schema\ helper. This ensures all tools, including MCP proxies, consistently request user intent and advertise the ability to retry oversized results without requiring individual tool implementations to manage these schema details.
crates/jcode-tool-core · high confidence
Centralized update logic and error handling in jcode-update-core
The \jcode-update-core\ crate now consolidates update-related contracts, GitHub DTOs, and helper functions into a single location. This introduces standardized types for update states (\PreparedUpdate\, \UpdateCheckResult\) and release data, along with utilities for estimating download and build durations. For users, this refactoring supports improved update reliability by providing specific, condensed error messages—such as a clear indication when local and upstream histories have diverged—rather than generic failure outputs.
crates/jcode-update-core · high confidence
Config edit reports now show which changes are live and which require a restart
When you edit your configuration file (via /config, manually, or by an agent), jcode now provides a clear summary of exactly what changed and whether the change takes effect immediately or requires a restart. Changes to most settings (like keybindings, display options, and provider preferences) are live in the running process. However, edits to gateway, ACP adapter, and launch hotkey settings require a restart to take effect, and the report explicitly lists these keys so you know when a restart is necessary.
crates/jcode-base/src/config · high confidence
Core library refactoring and platform-specific fixes
The jcode-core crate has been restructured to centralize shared utilities, introducing new modules for console ANSI handling, environment variable management, file permissions, ID generation, and output styling. This includes a fix for Windows consoles that previously displayed raw ANSI escape sequences by enabling Virtual Terminal processing, and a new configuration option to disable emoji output in terminals. Additionally, the crate now provides robust UTF-8 stream decoding for SSE data to prevent character truncation, improved stdin detection on Linux using /proc/PID/task/TID/children for better performance, and secure file permission setting on Windows using ACLs.
crates/jcode-core · high confidence
Crash-safe concurrency tracking for live Agent sessions
The telemetry system now accurately counts live runtime Agent sessions by using OS file locks to track ownership, ensuring that session counts remain correct even if an Agent crashes or is hard-killed without sending a final event. This change replaces the previous process-global activity accumulator with a scoped, crash-safe registry that distinguishes between root and child sessions, providing reliable concurrency metrics for the backend.
crates/jcode-telemetry-core · high confidence
Extract TUI tool display helpers
The TUI now uses a dedicated display layer to map provider-side tool names to user-friendly internal names (e.g., 'communicate' to 'swarm', 'discover\_tools' to 'integration\_tools') and to refine rendering logic for edit tools based on their input structure. This ensures that the interface presents consistent, readable labels and summaries for tool outputs, including better handling of error messages and exit codes.
crates/jcode-tui-tool-display · high confidence
Fix terminal routing for spawned windows and resume actions
Terminal spawns and resume actions now correctly open in the terminal window the user is currently attached to, rather than the server's original terminal. This is achieved by capturing client-side terminal environment variables (such as tmux, Herdr, and display server identifiers) and injecting them into spawned processes, ensuring external hooks and window managers target the correct location. Additionally, Windows resume command lines are now properly quoted to handle paths with spaces.
crates/jcode-terminal-launch · high confidence
Gateway now enforces strict authentication for remote WebSocket connections
The gateway in \crates/jcode-base/src/gateway\ now requires valid authentication during the WebSocket handshake. New modules (\auth.rs\, \registry.rs\) implement token extraction from headers or query parameters and validate them against a persisted device registry. Connections using revoked, unknown, or malformed tokens are immediately rejected with a 401 error, preventing unauthorized access. This change introduces a \DeviceRegistry\ that stores paired devices and their hashed tokens, ensuring that only authorized devices can establish a remote session.
crates/jcode-base/src/gateway · high confidence
Idle animations now use precomputed angle tables for significantly faster rendering
The TUI idle animations (donut, black hole, gyroscope) have been refactored to replace per-frame trigonometric calculations with precomputed lookup tables for fixed angle sequences. This change removes approximately 99% of the \cos\ and \sin\ calls in the animation loops, resulting in a substantial performance improvement (benchmarks show roughly 2x speedup for the donut animation) while maintaining bit-identical visual output. The core math kernels are now isolated in a dedicated \jcode-tui-anim\ crate, which is pinned to \opt-level = 3\ to ensure maximum optimization of these hot paths even in debug builds.
crates/jcode-tui-anim · high confidence
Improved 256-color palette mapping and macOS terminal compatibility
The TUI now detects fragile-glyph terminals on macOS (VS Code integrated terminal, Apple Terminal) and downgrades them from truecolor to the 256-color palette to prevent garbled glyphs. Additionally, the 256-color quantization algorithm has been updated to break ties by hue and compare against the grayscale ramp, ensuring that near-neutral colors (like dark gray-blues) map to neutral grays instead of saturated cube corners, resulting in more accurate color representation on limited-color terminals.
crates/jcode-tui-workspace · high confidence
Improved login feedback and new scriptable/device authentication flows
The CLI now explicitly notifies users when an API key is already configured, specifying whether it came from an environment variable or a config file, which prevents confusion when the prompt appears to hang. A new device-authorization flow allows users to log in to Jcode accounts by approving a request in a browser without entering credentials in the terminal. Additionally, scriptable login flows have been isolated and expanded to support providers like Claude, OpenAI, Gemini, and Google, enabling automated authentication in non-interactive environments.
src/cli/login · high confidence
Improved shell output rendering and background task status display
The message formatting layer now sanitizes ANSI escape sequences in shell command outputs to prevent terminal control codes from leaking into the UI or transcript. Additionally, background task notifications have been refined to display clearer status labels (completed, superseded, failed, running) and properly handle preview text normalization, ensuring a cleaner and more consistent presentation of asynchronous tool results.
crates/jcode-base/src/message · high confidence
Improved text selection, copy fidelity, and link handling in the TUI
The TUI now handles text selection and copying with greater accuracy and semantic awareness. Copying text that includes wide characters (such as CJK or emojis) no longer truncates the final character, ensuring complete selections. When copying rendered markdown, inline math is now converted to its LaTeX source code rather than copying the visual representation. Additionally, clicking on markdown-style links (e.g., \text\) within rendered labels will now correctly open the target URL, and users can toggle emoji rendering off to output plain ASCII symbols instead.
crates/jcode-tui/src/tui/ui · high confidence
Managed cloud phone host with hardened security and cost guardrails
The phone-server location now provides a complete, hardened AWS deployment for the jcode WebSocket gateway, including the wake and breaker Lambda functions, systemd units for the jcode daemon and idle auto-stop, and an idempotent TestFlight setup script. Security is tightened by removing public EC2 ingress, disabling the legacy pairing port in favor of SSM-based code generation, and enforcing least-privilege IAM policies with scoped Bedrock inference access. Cost control is ensured through multiple live-tested guardrails, including idle auto-stop, CloudWatch token alarms, and AWS Budget-based circuit breakers that automatically stop the instance if spending exceeds limits.
scripts/phone-server · high confidence
Memory deduplication and scoped injection logic
The memory system now prevents re-injecting recently seen memories into the same conversation transcript, using a 45-minute TTL to track injected memory IDs per session and suppress near-duplicate payloads. Pending memories are now bound to specific project scopes and Jev-selected metadata snapshots, with validation ensuring that selected facts are still active and unambiguous before injection. This change stabilizes context relevance by avoiding noise from repeated or stale memory suggestions within a single session.
crates/jcode-base/src/memory · high confidence
Mermaid diagram rendering is disabled by default
Mermaid diagram rendering is now disabled by default. Users must explicitly opt in to enable the feature, as the codebase has been refactored to extract the TUI Mermaid renderer into a dedicated crate with new debug, caching, and inline-image support modules.
crates/jcode-tui-mermaid/src · high confidence
Mermaid rendering now uses size metadata API by default
Mermaid diagrams in the TUI now automatically use the render size metadata API (introduced in mermaid-rs-renderer v0.3.0) for more accurate sizing, replacing the legacy SVG-retarget path. This behavior is enabled by default; users can revert to the legacy path by setting the environment variable JCODE\_MMDR\_SIZE\_API\_DISABLE=1.
crates/jcode-tui-mermaid · high confidence
New \[display\] configuration section and platform-aware keybinding defaults
The config schema now includes a dedicated \\[display\]\ section for TUI/CLI presentation settings, allowing users to control diff display modes, reasoning/thinking visibility, diagram rendering, LaTeX output, animation preferences, color themes, and notification styles. A lenient deserialization layer ensures that unrecognized enum values in these fields no longer discard the entire configuration file. Additionally, keybinding defaults are now split into explicit macOS and Windows/Linux lists with provenance tracking, enabling platform-specific shortcuts and validation checks for consistency.
crates/jcode-config-types · high confidence
Re-export local IPC transport from jcode-transport
The \jcode-base\ crate now re-exports the \jcode\_transport\ module, allowing the harness API bridge to access local IPC transport functionality without directly depending on the \jcode-base\ crate itself. This change supports the broader refactoring that splits \jcode-app-core\ into \jcode-base\ and \jcode-app-core\, ensuring that internal code paths using \crate::transport::...\ continue to work seamlessly.
crates/jcode-base/src/transport · high confidence
Refactor embedding backend into dedicated crate with robust ONNX input binding
The embedding logic has been extracted into a new \jcode-embedding\ crate, which now handles loading the \all-MiniLM-L6-v2\ ONNX model and tokenizer. To ensure compatibility across different model exporters, the embedder dynamically classifies ONNX inputs by name (e.g., \input\_ids\, \attention\_mask\) and binds them using their declared data types rather than assuming a fixed positional order. This change also upgrades the underlying \tract\ dependency to version 0.23 to resolve security advisory RUSTSEC-2026-0217 and adapts to API changes in the runnable model interface.
crates/jcode-embedding/src · high confidence
Refactored TUI message rendering with content-coordinate anchors and render caching
The \jcode-tui-messages\ crate has been restructured to improve scroll stability and rendering performance. It now uses content-coordinate anchors (based on message hashes and row positions) instead of raw line indices, ensuring that scroll positions remain accurate during window resizes or when history is compacted. Additionally, a new message cache system stores rendered lines keyed by content and display context (such as width, diagram mode, and tool call details), enabling efficient prefix-reuse rebuilds where unchanged message history is reused rather than re-rendered from scratch.
crates/jcode-tui-messages · high confidence
Refactored auth-test reporting and provider selection logic
The \jcode auth-test\ command now provides more accurate and diagnostic-friendly reports. The tool now correctly names the specific provider profile in test reports instead of the generic runtime slot, resolving confusion when using named OpenAI-compatible profiles. It also introduces explicit skip logic for providers that do not support tool-calling smoke tests (such as Cursor's text-only transport, FPT endpoints, and specific NVIDIA NIM models), preventing hangs and clarifying that basic chat validation still occurs. Additionally, credential path auditing has been improved to correctly identify the source environment file for named OpenAI-compatible profiles, and the tool now discovers available models from local OpenAI-compatible endpoints to ensure tests run against valid models.
_src/cli/auth\test · high confidence
Robust Claude Code session import and recency-based repo ranking
The import core now handles Claude Code session files more reliably by accepting \tool\_result\ content in array, string, or null formats, replacing embedded base64 image data with a compact \\[image\]\ placeholder to prevent context bloat, and gracefully skipping unknown block types without dropping entire messages. Additionally, a new recency-weighted repository ranking system analyzes session working directories to identify top projects, enabling the automatic generation of launch hotkeys for the user's most active repositories.
crates/jcode-import-core · high confidence
Robust PDF text extraction with panic recovery
The PDF extraction logic in the new \jcode-pdf\ crate now safely handles malformed PDFs that previously caused the underlying \pdf\_extract\ library to panic. Instead of crashing the task or surfacing a raw panic to the model, the system catches these panics and returns a standard error, ensuring stable operation when processing exotic or corrupted documents.
crates/jcode-pdf · high confidence
Standardized tool name resolution and unified output types
The tool system now normalizes various tool name aliases (such as PascalCase OAuth names like 'Bash' or 'Read', and prefixed names like 'functions.bash') to their canonical internal identifiers, ensuring that model-generated calls in batch subcalls resolve correctly. Additionally, tool outputs are now structured with a unified \ToolOutput\ type that supports optional titles, metadata, and embedded images, providing a consistent interface for tool results.
crates/jcode-tool-types · high confidence
Support for multi-word skill names in slash commands
The skill invocation parser now correctly resolves slash commands that include spaces, such as \/My Custom Skill\. The system matches the longest registered skill name first, allowing users to invoke skills with descriptive, multi-word titles while preserving any trailing prompt text. If no exact multi-word match is found, it falls back to single-token matching for backward compatibility.
crates/jcode-base/src/skill · high confidence
Swarm plan graph rendering reliability and stress testing
The swarm plan Mermaid graph now renders reliably and legibly, addressing previous issues where the visualization might fail or become unreadable. This change includes a new stress-probe example (\swarm\_plan\_stress\) and a real plan fixture (\swarm\_plan\_fixture.json\) to validate the renderer against hostile inputs, such as unicode glyphs, special characters, and duplicate IDs, ensuring the TUI displays task dependencies correctly even in complex scenarios.
crates/jcode-tui-mermaid/examples · high confidence
Typo-resistant fuzzy search with performance optimizations
The fuzzy matching engine in the terminal and desktop UIs now supports typo resistance by allowing a bounded number of substitutions, transpositions, and extra characters, while still prioritizing exact, consecutive, and boundary matches. To improve picker responsiveness, the implementation introduces a bitmask prefilter for cheap rejection of non-matches, an allocation-free scoring path for score-only lookups, and fixes to the ranking logic to prevent positional penalties from incorrectly rejecting valid late matches.
crates/jcode-fuzzy/src · high confidence
Unified multi-account management and credential resolution for Anthropic and OpenAI
The authentication system now centralizes how Anthropic and OpenAI accounts are managed and selected. It introduces a persistent auto-switch pool that rotates through available accounts when the primary one is exhausted, while explicitly excluding metered API keys from automatic failover to prevent unexpected billing. Multi-account logins are now identified by stable, memorable animal-based labels (e.g., \claude-otter\, \openai-fox\) instead of opaque identifiers, and existing accounts are automatically migrated to this new naming scheme. A single source of truth now resolves whether OAuth or API-key credentials are active for dual-auth providers, ensuring UI indicators and backend requests stay consistent. Additionally, imported legacy credentials (such as those from the Codex CLI) now automatically derive token expiration times from JWT claims, preventing premature login prompts caused by missing expiry data.
crates/jcode-base/src/auth · high confidence
Fixes
1 commit (1 fix) fixing crates/jcode-base/src/config\_tests
A fix in crates/jcode-base/src/config\_tests — 1 commit (1 fix), 1 file: “Isolate provider reload regression within test size budget”.
_crates/jcode-base/src/config\tests · medium confidence · unverified
19 commits (12 fixes) fixing crates/jcode-provider-copilot-runtime
A fix in crates/jcode-provider-copilot-runtime — 19 commits (12 fixs), 4 files: “fix: route Copilot GPT-5.6 through responses (fixes \#1060)”; “websearch: prefer provider-native search by default; respect session tool policy”; “fix(copilot): send Sonnet 5 reasoning effort (fixes \#558)”; and 11 more (refs \#1060, \#558, \#561, \#2087, \#1643).
crates/jcode-provider-copilot-runtime · medium confidence · unverified
53 commits (29 fixes) fixing crates/jcode-provider-anthropic
A fix in crates/jcode-provider-anthropic — 53 commits (29 fixs), 8 files: “fix: forward OAuth Bash timeout and execution schema (fixes \#1223)”; “fix: never wedge a session with duplicate tool\_results”; “test(anthropic): cover orphaned native web-search history”; and 38 more (refs \#1223, \#1135, \#409, \#572, \#600, …).
crates/jcode-provider-anthropic · medium confidence · unverified
90 commits (46 fixes) fixing crates/jcode-provider-anthropic-runtime
A fix in crates/jcode-provider-anthropic-runtime — 90 commits (46 fixs), 14 files: “tui: show the account email on failover switches and drop repeated failover lines”; “refactor: restore owned Rust budgets and handle runtime errors”; “fix(anthropic): force model discovery past fresh catalog caches”; and 68 more (refs \#1135, \#578, \#2087, \#620, \#626, …).
crates/jcode-provider-anthropic-runtime · medium confidence · unverified
Fix Copilot model ID format and message building logic
The Copilot provider now uses dot-separated catalog IDs (e.g., \claude-sonnet-4.6\) instead of hyphenated forms, preventing HTTP 400 \model\_not\_supported\ errors. Additionally, the message builder correctly pairs tool\_use blocks with their corresponding tool\_result blocks, handling out-of-order results and missing outputs to ensure valid OpenAI-compatible message arrays.
crates/jcode-provider-copilot · high confidence
Fix consumer account 429 errors by switching to daily-cloudcode-pa endpoint
The Antigravity provider now defaults to the \daily-cloudcode-pa.googleapis.com\ endpoint instead of the previous \cloudcode-pa.googleapis.com\. This change resolves HTTP 429 RESOURCE\_EXHAUSTED errors that consumer (@gmail.com) accounts were encountering, as the non-daily host rejects valid requests for the \aicode-consumers\ project. The new endpoint is configurable via the \JCODE\_ANTIGRAVITY\_ENDPOINT\ environment variable, and the system now validates endpoint URLs to prevent silent failures from malformed overrides.
crates/jcode-provider-antigravity · high confidence
Fix: Retry logic now correctly identifies TLS BadRecordMac errors
The retry classification logic has been updated to recognize TLS \BadRecordMac\ errors as transient, ensuring that requests failing due to corrupted network records (such as those caused by middleboxes or flaky VPNs) are retried instead of failing immediately. This change aligns the OpenAI provider's error handling with the shared transport classifier, which now explicitly checks for \bad\_record\_mac\ and related fatal alerts within the full error chain, preventing these specific network faults from masking as permanent failures.
scripts/repro/tls-bad-record-mac · high confidence
Fixes credential loading issues with invisible Unicode characters and stale environment variables
The credential loading logic in the provider-env crate has been updated to handle two specific failure modes. First, it now strips Unicode invisible characters (such as zero-width spaces and non-breaking spaces) from API keys and config values, which previously caused silent authentication failures; a warning is logged if such characters are detected. Second, a new \load\_env\_value\_from\_config\_file\ function allows the system to read credentials directly from the config file, bypassing inherited environment variables. This ensures that an explicit \/login\ action correctly updates the active credentials even if a stale API key remains in the long-lived server process's environment.
crates/jcode-provider-env · high confidence
Fixes lost cancellation signals during rapid user interrupts
The agent runtime now reliably processes cancellation requests (such as pressing Esc) even when they occur rapidly or concurrently with tool execution. This is achieved by introducing an epoch-based guard in the \InterruptSignal\ mechanism, which prevents deferred reset operations from accidentally erasing newer cancel signals, and by explicitly registering async waiters to eliminate potential lost wakeups. Users will no longer experience situations where their interrupt commands appear to be ignored or swallowed by the system.
crates/jcode-agent-runtime · high confidence
Improved error messaging and support for headless swarm socket connections
The swarm communication tool now provides clearer, actionable error messages when the server is not running, replacing generic connection errors with a specific message guiding users to start the server. Additionally, it fixes an issue where headless \run --socket\ commands failed to connect to the swarm; the tool now automatically starts an ephemeral server if one is not already bound to the socket, ensuring swarm functionality works correctly in non-interactive contexts.
crates/jcode-app-core/src/tool/communicate · high confidence
TUI: fix dead terminal mislabeling live sessions as Crashed
Resolves an issue where a terminated or unresponsive terminal would incorrectly cause the TUI to mark an otherwise active session as 'Crashed'. The fix ensures that session status is accurately reflected even when the underlying terminal process has died, preventing false crash notifications and allowing users to continue interacting with live sessions. Also in this area: 12 commits (0 fixes) modifying crates/jcode-tui/src/tui/app; 3 commits adding/updating tests in crates/jcode-tui/src/tui/app/tests/scroll\_copy\_02; 2 commits (1 fix) modifying crates/jcode-tui; Cloud session replacement and swarm status visibility; Added tests for remote TUI service tier handling and session reload logic; and 12 more.
crates/jcode-tui/src/tui/app · medium confidence · unverified
agentgrep: honor 'file' parameter for precise grep/find scoping
The agentgrep tool now correctly respects the 'file' input parameter to restrict grep and find operations to a single specific file, addressing issue \#538. Previously, this parameter was ignored, causing searches to potentially span broader directories than intended. The implementation in args.rs resolves the 'file' argument into a precise search scope (root + glob) when 'path' is absent, ensuring that users targeting a specific file get results limited to that file only.
crates/jcode-app-core/src/tool/agentgrep · high confidence
Test coverage
1 commit adding/updating tests in crates/jcode-base/src/session/crash; 1 commit adding/updating tests in crates/jcode-tui-mermaid/src/mermaid\_runtime; 2 commits adding/updating tests in crates/jcode-base/src/recent\_session\_index; Added Rust SDK integration tests for client behavior, lifecycle, and structured output; Added UI test coverage for TUI rendering and performance policies; Added Windows-specific tests for SyncStream duplex and recovery behavior; Added acceptance tests for the public MCP CLI; Added agent lifecycle and behavior tests; Added comprehensive UI rendering tests for TUI components; Added comprehensive test coverage for LaTeX rendering robustness and streaming stability; Added differential fuzzing script for niri insert point; Added fuzz-audit tests for swarm gallery, panel, and strip renderers; Added harness API capability coverage and schema snapshot tests; Added ignored integration tests for the Mermaid layout-tier cache; Added integration tests for Claude import, MCP stdio collision, login QR, prompt guidance, and auth cache; Added integration tests for TUI launch behavior on Unix; Added latency regression test for embedding inference; Added protocol test coverage for swarm, communication, and core event serialization; Added regression tests for TUI rendering stability and concurrency; Added session logic tests; Added tests for MCP collision handling and SDK session tool policies; Added tests for Mermaid viewport rendering, aspect-ratio handling, and scroll performance; Added tests for deferred LaTeX rendering and syntax highlighting performance; Added tests for device-code login polling and credential persistence; Added tests for provider authentication, catalog scoping, and model resolution; Added tests for provider schema sanitization and MCP tool handling; Expanded CLI argument parsing and validation coverage; Expanded end-to-end test coverage for ambient mode, burst spawning, and session resilience; New test suite for TUI markdown rendering behaviors.
Dependencies
Workspace restructured into modular crates with Rust 2024 edition
The project has been refactored from a monolithic structure into a multi-crate workspace, migrating the edition to 2024. This change extracts the application core into \jcode-app-core\ and the foundational layer into \jcode-base\ to reduce compile times, while isolating provider runtimes (e.g., \jcode-provider-anthropic-runtime\), types, and utilities into dedicated leaf crates. The \Cargo.lock\ file is now generated for the workspace, and dependencies such as \reqwest\, \tokio\, and \serde\ are explicitly versioned across the new modules.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 55 → 51 (-4.5)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 47 → 50 (+3.5)
- Architecture 88 → 88 (-0.3)
- Maturity 81 → 74 (-6.7)
- Readiness 56 → 61 (+4.7)
- Security 54 → 38 (-16.0)
- Event-Driven 100 → 100 (+0.0)
- Event Sourcing 100 → 100 (+0.0)
- Performance 70 → 70 (+0.0)
Resolved (677)
- Agent::parse_text_wrapped_tool_call (cognitive 17) (crates/jcode-app-core/src/agent/response_recovery.rs)
- App::format_usage_display_card (cognitive 31) (crates/jcode-tui/src/tui/app/model_context.rs)
- App::format_usage_display_card (cyclomatic 18) (crates/jcode-tui/src/tui/app/model_context.rs)
- App::handle_session_picker_key (cognitive 22) (crates/jcode-tui/src/tui/app/inline_interactive.rs)
- App::handle_session_picker_key (cyclomatic 21) (crates/jcode-tui/src/tui/app/inline_interactive.rs)
- App::open_account_center (cognitive 31) (crates/jcode-tui/src/tui/app/auth_account_picker.rs)
- App::open_account_center (cyclomatic 27) (crates/jcode-tui/src/tui/app/auth_account_picker.rs)
- BackgroundTaskManager::cleanup_filtered (cognitive 38) (crates/jcode-base/src/background.rs)
- BackgroundTaskManager::cleanup_filtered (cyclomatic 19) (crates/jcode-base/src/background.rs)
- BashTool::execute_foreground (cognitive 52) (crates/jcode-app-core/src/tool/bash.rs)
- BashTool::execute_foreground (cyclomatic 20) (crates/jcode-app-core/src/tool/bash.rs)
- BedrockProvider::refresh_catalog (cognitive 38) (crates/jcode-provider-bedrock/src/lib.rs)
- BedrockProvider::refresh_catalog (cyclomatic 20) (crates/jcode-provider-bedrock/src/lib.rs)
- Boundary-crossing change coupling: process_title.rs ↔ dispatch.rs (crates/jcode-base/src/process_title.rs)
- BridgeState::search_session_text (cognitive 22) (crates/jcode-harness-api-server/src/translate.rs)
- BridgeState::walk_files (cognitive 27) (crates/jcode-harness-api-server/src/translate.rs)
- Change coupling: anthropic.rs ↔ pricing.rs (crates/jcode-base/src/provider/anthropic.rs)
- Change coupling: comm_control.rs ↔ comm_plan.rs (crates/jcode-app-core/src/server/comm_control.rs)
- Change coupling: display_summary.rs ↔ lib.rs (crates/jcode-base/src/config/display_summary.rs)
- Change coupling: hooks.rs ↔ lib.rs (crates/jcode-base/src/hooks.rs)
- …and 657 more
New (1273)
- AnthropicProvider::get_oauth_access_token (cyclomatic 16) (crates/jcode-provider-anthropic-runtime/src/lib.rs)
- AnthropicProvider::refresh_catalogs (cognitive 18) (crates/jcode-provider-anthropic-runtime/src/catalog.rs)
- App::cycle_account (cognitive 24) (crates/jcode-tui/src/tui/app/auth_account_picker.rs)
- App::format_usage_provider_card (cognitive 18) (crates/jcode-tui/src/tui/app/model_context.rs)
- App::handle_account_picker_selection (cognitive 18) (crates/jcode-tui/src/tui/app/inline_interactive.rs)
- App::handle_account_picker_selection (cyclomatic 17) (crates/jcode-tui/src/tui/app/inline_interactive.rs)
- App::handle_provider_failover_prompt_with_payload (cognitive 34) (crates/jcode-tui/src/tui/app/model_context.rs)
- App::handle_provider_failover_prompt_with_payload (cyclomatic 23) (crates/jcode-tui/src/tui/app/model_context.rs)
- App::handle_session_picker_action (cognitive 20) (crates/jcode-tui/src/tui/app/inline_interactive.rs)
- App::handle_session_picker_action (cyclomatic 19) (crates/jcode-tui/src/tui/app/inline_interactive.rs)
- App::handle_session_picker_current_terminal_selection (cognitive 17) (crates/jcode-tui/src/tui/app/inline_interactive.rs)
- App::handle_session_picker_current_terminal_selection (cyclomatic 19) (crates/jcode-tui/src/tui/app/inline_interactive.rs)
- App::handle_ssh_login_with_label (cognitive 16) (crates/jcode-tui/src/tui/app/auth_remote.rs)
- App::open_account_center (cognitive 32) (crates/jcode-tui/src/tui/app/auth_account_picker/account_center.rs)
- App::open_account_center (cyclomatic 28) (crates/jcode-tui/src/tui/app/auth_account_picker/account_center.rs)
- App::poll_cloud_job (cognitive 24) (crates/jcode-tui/src/tui/app/commands_cloud.rs)
- App::poll_cloud_job (cyclomatic 23) (crates/jcode-tui/src/tui/app/commands_cloud.rs)
- App::process_queued_messages (cyclomatic 17) (crates/jcode-tui/src/tui/app/input.rs)
- App::refresh_completed_todo_report (cognitive 19) (crates/jcode-tui/src/tui/app/todo_completion.rs)
- App::refresh_completed_todo_report (cyclomatic 19) (crates/jcode-tui/src/tui/app/todo_completion.rs)
- …and 1253 more
Changes since last survey
- 300 commits — 240 feature/other, 60 fixes
By area
- crates/jcode-tui — 119 commits
- crates/jcode-app-core — 49 commits
- crates/jcode-base — 34 commits
- src/cli — 13 commits
- vendor/ratatui-jcode — 8 commits
- crates/jcode-sdk — 6 commits
- docs/images — 6 commits
- docs/badges — 5 commits
- telemetry-worker/src — 5 commits
- (root) — 4 commits
- crates/jcode-provider-anthropic-runtime — 4 commits
- docs/LIVE_LOCAL_PRODUCTION_ACCEPTANCE.md — 4 commits
- (repo) — 3 commits
- crates/jcode-tui-markdown — 3 commits
- crates/jcode-voice — 3 commits
- docs/MOBILE_CLOUD_CONTINUATION.md — 3 commits
- .github/workflows — 2 commits
- crates/jcode-harness-api-server — 2 commits
- crates/jcode-provider-core — 2 commits
- docs/CLOUD_LATENCY.md — 2 commits
Notable commits
- fix: Fix #2087: buffer UTF-8 across SSE chunks in Anthropic and Copilot streams
- fix: Fix immediate provider failover dispatch and fence exhaustion retries
- fix: Revert "Make TUI activity status columns stable across phases"
- fix: Revert "Restore compact comprehensive TUI activity status"
- fix: fix(agent): preserve separate notification delivery events
- fix: fix(agent): publish turn context notification entries
- fix: fix(anthropic): add Fable 5.2, Sonnet 5.5 and Haiku 5.5 to the bundled Claude catalog
- fix: fix(app-core): handle safety failures and production lint blockers
- fix: fix(build): sweep stale launcher backups on Windows publish (#2065)
- fix: fix(ci): clear ratatui preview clippy blockers
- fix: fix(ci): clear the panic and swallowed-error ratchets blocking previews
- fix: fix(ci): handle terminal cache failures and limit usage test helper
- fix: fix(ci): resolve remaining ratatui widget lint failures
- fix: fix(compaction): reject refused or empty summaries instead of dropping messages (fixes #2089)
- fix: fix(config): track resume override in cache fingerprint
- fix: fix(provider): respect cached account exhaustion and newer cooldowns
- fix: fix(providers issue #1939): accept http base URLs with any IP address (#2018)
- fix: fix(push): cancel delayed failure alerts when session resumes
- fix: fix(resume): rank fork-local requests above incidental title matches
- fix: fix(sdk): start the standalone API bridge where the CLI has no api-bridge
- …and 280 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
1jehuang/jcode was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 374ed3ecacdc2a08ecd1cdef6a57a036060e424d — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.