1jehuang/jcode

Jcode is a multi-platform AI coding assistant that provides a terminal-based TUI, a desktop application, and an iOS app for interacting with various LLM providers. It features a robust agent runtime capable of managing complex swarm-based task planning, background operations, and persistent session recovery. The system supports native voice dictation, graph-based memory retrieval, and extensive tool integration, all secured through a centralized authentication and gateway architecture.

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

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 · high confidence

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

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

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

A new example, \swarm\_agent\_count\, has been added to the \jcode-plan\ crate. This tool drives the underlying task-DAG engine with scripted mock workers to measure and report specific runtime metrics, including total nodes, dispatches (agent spawns), auto-inserted gates, and peak concurrency. It allows users to reproduce and verify how different task shapes and modes (Light vs. Deep) affect the number of agents spawned and the complexity of the resulting graph.

crates/jcode-plan/examples · high confidence

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

The Anthropic provider runtime has been moved into its own crate (\jcode-provider-anthropic-runtime\) to improve build times and isolate provider-specific logic. This update adds support for new model families including Claude Opus 5.5 (with mandatory adaptive thinking) and Claude Fable 5, and introduces configurable reasoning effort levels (none, low, medium, high, xhigh) that shape request payloads and fallback behavior. Context window limits are now resolved via a cache-aware lookup to ensure accurate metering and compaction budgets. The runtime also supports Anthropic-compatible custom profiles via environment variables and configuration files, allowing users to point to third-party endpoints with custom authentication and headers. Streaming stability is improved with a stall guard to prevent hanging requests, and authentication routes are refreshed independently to handle OAuth token expiration more gracefully.

crates/jcode-provider-anthropic-runtime · high confidence

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.

crates/jcode-app-core · high confidence

The Copilot provider runtime has been extracted from \jcode-base\ into the new \jcode-provider-copilot-runtime\ crate to isolate compilation and allow provider-specific edits without rebuilding the entire application spine. This change introduces support for routing GPT-5.6 family models through the new \responses\ API endpoint and enables sending \reasoning\_effort\ parameters for Claude Sonnet 5 models. It also includes a comprehensive test suite covering model catalog handling, token parameter selection, and context window limits.

crates/jcode-provider-copilot-runtime · high confidence

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

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

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

The session render layer now attaches aggregated response statistics to assistant message rows, allowing users to see input/output token counts and cache read/creation metrics for each turn. The new \response\_stats.rs\ module identifies user prompts to define turn boundaries, sums token usage across all assistant messages within a turn (including those hidden by tool calls), and attaches the resulting \ResponseStats\ to the corresponding rendered row, ensuring that compacted views still reflect the full turn's usage.

crates/jcode-base/src/session/render · high confidence

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

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

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

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.

crates/jcode-provider-bedrock · high confidence

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

Added the JCodeKit Swift package to ios/Sources, providing the core networking and state-management layer for the iOS app. This includes Connection.swift for WebSocket lifecycle and reconnect logic, CredentialStore.swift for secure keychain-based credential persistence, Gateway.swift and Pairing.swift for server discovery and pairing flows, SessionReducer.swift for client-side session state management, and Wire.swift for protocol serialization. This change establishes the foundational client library that the iOS app relies on for communication with the jcode server.

ios/Sources/JCodeKit · high confidence

This change adds the JCodeMobile iOS application scaffold, providing a SwiftUI-based interface for connecting to JCode servers. Users can pair devices by scanning QR codes via the camera, manage multiple server credentials stored in the keychain, and engage in chat sessions with markdown rendering (including fenced code blocks with copy support). The app features a dark terminal-native theme, automatic reconnection on app resume, and allows interrupting or canceling mid-run messages. Configuration includes ATS exceptions for local/Tailscale networking and a privacy manifest declaring only UserDefaults usage for device identification.

ios/Sources/JCodeMobile · high confidence

The iOS app now uses a new SwiftUI-based chat interface (JCodeMobile v2) that replaces the previous implementation. This update adds a connection status banner with manual retry, server notices, and queued interrupt handling. The chat composer now supports interrupting ongoing responses and queuing messages while processing. Accessibility has been improved with proper labels, hints, and 44pt touch targets. The interface also includes a pairing view for connecting to servers, settings for model selection and session management, and improved transcript scrolling behavior that respects user scroll position.

ios/Sources/JCodeMobile/Views · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The TestHarness now includes a new reward framework that scores UI changes on a 0–100 scale using six weighted categories: Space & density, Ergonomics & interaction, Visual clarity, Legibility & accessibility, Responsiveness, and Design authenticity & craft. The system runs headlessly via screenshots and source analysis, with a new Category F that penalizes AI-generated UI patterns (e.g., purple/indigo palettes, glassmorphism overuse, generic fonts) to encourage authentic design. The aggregator discovers scorer modules, computes per-cell and overall rewards, and supports regression gating via baseline/candidate JSON reports.

ios/TestHarness/reward · high confidence

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

A new \jcode-plan\ crate centralizes swarm plan state, providing a task-DAG engine for validation and execution, a bridge to persist plans via \VersionedPlan\, and Mermaid graph generation for the TUI. This introduces a 1,024-item cap on plan graphs to prevent unbounded growth, adds deep-mode support with gate-based audits and artifact handoffs, and ensures reliable, legible rendering of plan dependencies in the user interface.

crates/jcode-plan/src · high confidence

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

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

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

The swarm planning system now uses a directed acyclic graph (DAG) to manage tasks, replacing the previous flat or less-structured approach. This engine supports two modes: 'Light' for cheap parallelism without mandatory verification, and 'Deep' which enforces strict gates (Critique/Verify) and artifact validation before tasks can close. Tasks are now typed (Explore, Implement, Verify, Fix, Synthesize, Critique) and tracked with origins (Seed, Expand, Gap, Gate) and confidence levels. The scheduler handles dependency resolution, worker dispatch, and dataflow hydration (passing artifacts between nodes). A deterministic simulator is included for testing the engine's logic without live agents. This change provides a more rigorous and auditable planning process, especially in Deep mode, ensuring that complex tasks are properly decomposed and verified.

crates/jcode-plan/src/dag · high confidence

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

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

The authentication module now supports native, cancellable OAuth login flows for desktop environments. A new local TCP callback listener (callback.rs) securely receives browser redirects on localhost without logging credentials or URLs, validating the state and redirect URI to prevent interception. This enables users to start a login, cancel it, or retry safely, with proper resource release and clear error messages for timeouts or failed callbacks. Tests verify the round-trip flow, ensuring sensitive data is passed via stdin rather than command-line arguments, and that legacy validation responses are handled correctly.

crates/jcode-sdk/src/auth · high confidence

The CLI now supports built-in voice dictation, allowing users to speak commands directly without external tools. Audio is captured via native APIs (cpal) or external recorders (PulseAudio, PipeWire, ALSA, SoX, ffmpeg) and streamed to the Nari speech-to-text service for real-time transcription. The system includes a built-in vocabulary and correction rules to accurately recognize product-specific terms like 'Jev' and 'Jcode', and filters out accidental prompt echoes. Users can also define custom recorder commands for specific audio setups.

crates/jcode-base/src/voice · high confidence

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

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

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

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.

crates/jcode-provider-openai · high confidence

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.

crates/jcode-sdk/src · high confidence

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

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

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

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

The TestHarness now includes a comprehensive set of automated scorers to evaluate iOS UI quality across five categories. Accessibility (D) checks for VoiceOver labels, Dynamic Type usage, and icon-only button defects. AI-pattern detection (F) penalizes generic 'AI-slop' indicators like specific color palettes, gradient text, and generic fonts. Consistency (C) measures palette discipline and source token usage. Content safety (A) ensures content does not bleed into OS chrome or clip at screen edges. Information density (A) distinguishes between useful transcript content and fixed chrome, with specific handling for empty states. Interaction cost (B) uses a graph-based engine grounded in real user logs and HCI models to estimate effort. Layout robustness (E) detects fragility signals like chrome bleed and suspicious full-width rows. Contrast (D) grades WCAG text/background contrast on rendered pixels. Performance (E) scores launch and jank metrics when available. Reachability (B) verifies primary actions are in the thumb zone. Rhythm (C) checks for 8pt grid spacing. Simplicity (F) penalizes deep nesting and excessive primitives. These scorers provide a blended 0-100 score with detailed evidence for regression tracking.

ios/TestHarness/reward/scorers · high confidence

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

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

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

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.

crates/jcode-provider-openai-runtime/src · high confidence

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

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

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

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

The ios/TestHarness directory now provides a complete end-to-end testing environment for the JCodeMobile iOS app, replacing the previous Rust simulator. It includes a Python-based mock gateway that simulates the server wire protocol (pairing, WebSocket streaming, tool calls) without requiring an LLM or network, enabling repeatable client development. The harness features an automated pipeline (run\_e2e.sh) that builds the app, seeds credentials for auto-connection, and captures simulator screenshots. Additionally, it introduces a UI efficiency measurement system: ui\_matrix.py scores layouts across multiple devices and Dynamic Type sizes, ui\_metrics.py analyzes screenshots for space, consistency, legibility, and rhythm, and ui\_lint.py enforces source-level design token discipline. A production readiness gate (check\_production.sh) verifies app store requirements and test determinism.

ios/TestHarness · high confidence

The iOS TestHarness now includes a graph-based interaction-cost engine that estimates user effort in seconds to inform reward calculations. This new module grounds its model in real usage data by mining local TUI logs to determine action frequencies, mapping SwiftUI source code to extract precise control geometry for Fitts' law calculations, and applying HCI standards (KLM/TLM) to price individual user actions. The engine synthesizes these inputs into a weighted ActionGraph to compute expected per-action costs and task completion times, providing a data-driven metric for optimizing the mobile user experience.

ios/TestHarness/reward/interaction · high confidence

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

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

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

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

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

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

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

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

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

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

A new \jcode-tui-visual-debug\ crate has been added to isolate visual debugging support. This feature captures detailed TUI frame state—including layout areas, rendered text, timing information, and application state snapshots—and writes them to a debug file. This allows users to diagnose visual bugs in the terminal interface by analyzing the captured data, even without direct access to the terminal display.

crates/jcode-tui-visual-debug · high confidence

Added four new CLI examples in \crates/jcode-base/examples\ to demonstrate and test the new voice capabilities: \nari\_pcm\ accepts raw PCM files for transcription, \voice\_recorder\ simulates push-to-talk recording with external audio tools, \voice\_startup\_profile\ measures microphone capture and session startup latency, and \voice\_intent\_latency\ benchmarks the voice intent classification routing against multiple session candidates.

crates/jcode-base/examples · high confidence

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

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

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

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

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.

telemetry-worker · high confidence

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

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

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

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

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

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

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

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

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

A change to existing behaviour in assets/app-icons — 2 commits (1 fix), 1 file.

assets/app-icons · medium confidence · unverified

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.

crates/jcode-base/src/background · high confidence

Build metadata (version, git hash, changelog) is now generated in the new \jcode-build-meta\ crate instead of the root \jcode\ crate, ensuring all workspace crates share identical compile-time values. This change significantly improves build performance by preventing full-tree recompilations triggered by routine git activity, as the build script now only re-runs on actual source or \Cargo.toml\ changes rather than every git operation. Additionally, the metadata system now supports a fast-release path where runtime overrides can replace compile-time values without recompiling the dependency graph.

crates/jcode-build-meta · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 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 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

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

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

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

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

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

Sessions that crash or encounter corrupt journal lines are now recovered automatically: the system detects crashed sessions, prunes stale backup files to save disk space, and replays journals by salvaging glued or torn lines instead of dropping the rest of the transcript. This ensures that resumed sessions retain their last prompts and messages even after unexpected interruptions or file corruption.

crates/jcode-base/src/session · high confidence

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

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

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

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

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

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

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

The usage module in jcode-base has been expanded to handle Anthropic session-limit resets (allowing users to claim weekly resets via the /limit-reset contract) and to track OpenAI/Codex OAuth usage across dynamic five-hour and seven-day windows. This includes cross-process caching of usage data to prevent API throttling, real-time key status probes for API-key profiles, and display logic that correctly zeroes out usage windows after their reset timestamps pass.

crates/jcode-base/src/usage · high confidence

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

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

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

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

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

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.

crates/jcode-tui/src · high confidence

Added OAuth test suite for PKCE, token serialization, and provider flows; Added Rust SDK integration tests for client behavior, lifecycle, and structured output; Added comprehensive test coverage for LaTeX rendering robustness and streaming stability; Added differential fuzzing script for niri insert point; Added e2e test support infrastructure; 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 Anthropic provider message formatting; Added regression tests for TUI rendering stability and concurrency; Added session logic tests; Added test suite for JCodeKit core connection, session, and wire protocols; 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 notification reaping behavior; Added tests for provider authentication, catalog scoping, and model resolution; Added tests for provider schema sanitization and MCP tool handling; Enforce SDK surface parity between Rust and TypeScript clients; Expanded CLI argument parsing and validation coverage; Expanded end-to-end test coverage for ambient mode, burst spawning, and session resilience; Expanded test coverage for CLI, authentication, and context resolution; Expanded test coverage for OpenAI runtime stability and behavior; New test suite for TUI markdown rendering behaviors.

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 watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 57 → 55 (-2.2)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 49 → 48 (-0.8)
• Architecture 99 → 87 (-12.3)
• Maturity 81 → 79 (-1.9)
• Readiness 49 → 48 (-0.4)
• Security 63 → 74 (+11.4)
• Event-Driven 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Performance 60 (new)

• App::scroll_down (cognitive 17) (crates/jcode-tui/src/tui/app/navigation.rs)
• Boundary-crossing change coupling: claude.rs ↔ test_api.rs (crates/jcode-base/src/provider/claude.rs)
• Boundary-crossing change coupling: process_title.rs ↔ args.rs (crates/jcode-base/src/process_title.rs)
• Change coupling: anthropic.rs ↔ pricing.rs (crates/jcode-base/src/provider/anthropic.rs)
• Change coupling: inline_interactive.rs ↔ ui_inline_interactive.rs (crates/jcode-tui/src/tui/app/inline_interactive.rs)
• Change coupling: remote.rs ↔ replay.rs (crates/jcode-tui/src/tui/app/remote.rs)
• Change-coupling hub: core_events.rs → client_lifecycle.rs, server_events.rs, backend.rs (crates/jcode-protocol/src/protocol_tests/core_events.rs)
• ClassTooLong: MemoryAgent (crates/jcode-base/src/memory_agent.rs)
• ClaudeEventTranslator::handle_event (cognitive 19) (crates/jcode-provider-claude-cli-runtime/src/lib.rs)
• ClaudeEventTranslator::handle_event (cyclomatic 23) (crates/jcode-provider-claude-cli-runtime/src/lib.rs)
• ClaudeProvider::complete (cognitive 21) (crates/jcode-provider-claude-cli-runtime/src/lib.rs)
• CliOutputParser::handle_output (cognitive 43) (crates/jcode-provider-claude-cli-runtime/src/lib.rs)
• CliOutputParser::handle_output (cyclomatic 26) (crates/jcode-provider-claude-cli-runtime/src/lib.rs)
• Documentation: no architecture or design documentation (README.md)
• Duplicated block (10 lines × 2) (crates/jcode-tui/src/tui/info_widget_usage.rs)
• Duplicated block (10 lines × 3) (crates/jcode-base/src/memory.rs)
• Duplicated block (11 lines × 3) (crates/jcode-base/src/usage/provider_fetch.rs)
• Duplicated block (12 lines × 2) (crates/jcode-base/src/memory_agent.rs)
• Duplicated block (12 lines × 2) (crates/jcode-tui/src/tui/app/local.rs)
• Duplicated block (12 lines × 2) (crates/jcode-tui/src/tui/info_widget_git.rs)
• …and 238 more

• Agent::export_conversation_markdown (cyclomatic 16) (crates/jcode-app-core/src/agent.rs)
• Agent::tool_definitions (cognitive 17) (crates/jcode-app-core/src/agent/turn_execution.rs)
• Agent::validate_tool_allowed (cognitive 18) (crates/jcode-app-core/src/agent/turn_execution.rs)
• Agent::validate_tool_allowed (cyclomatic 16) (crates/jcode-app-core/src/agent/turn_execution.rs)
• AppletTool::execute (cognitive 23) (crates/jcode-app-core/src/tool/applet.rs)
• AppletTool::execute (cyclomatic 21) (crates/jcode-app-core/src/tool/applet.rs)
• AuthRetryStream::poll_next (cognitive 16) (crates/jcode-provider-grok-build-runtime/src/lib.rs)
• Boundary-crossing change coupling: discover.rs ↔ benchmark_discovery.py (crates/jcode-app-core/src/tool/discover.rs)
• Change coupling: accessors.rs ↔ external.rs (crates/jcode-base/src/provider/accessors.rs)
• Change coupling: activation.rs ↔ selection.rs (crates/jcode-base/src/provider/activation.rs)
• Change coupling: client_lifecycle.rs ↔ core_events.rs (crates/jcode-app-core/src/server/client_lifecycle.rs)
• Change coupling: client_session.rs ↔ comm_plan.rs (crates/jcode-app-core/src/server/client_session.rs)
• Change coupling: comm_control.rs ↔ comm_plan.rs (crates/jcode-app-core/src/server/comm_control.rs)
• Change coupling: core_events.rs ↔ client_state.rs (crates/jcode-app-core/src/protocol_tests/core_events.rs)
• Change coupling: core_events.rs ↔ server_events.rs (crates/jcode-app-core/src/protocol_tests/core_events.rs)
• Change coupling: core_events.rs ↔ server_events.rs (crates/jcode-protocol/src/protocol_tests/core_events.rs)
• Change coupling: edit.rs ↔ write.rs (crates/jcode-app-core/src/tool/edit.rs)
• Change coupling: env_overrides.rs ↔ hooks.rs (crates/jcode-base/src/config/env_overrides.rs)
• Change coupling: external.rs ↔ catalog.rs (crates/jcode-base/src/auth/external.rs)
• Change coupling: external.rs ↔ provider_catalog.rs (crates/jcode-base/src/auth/external.rs)
• …and 421 more

• 300 commits — 210 feature/other, 90 fixes

• crates/jcode-base — 81 commits
• crates/jcode-tui — 71 commits
• crates/jcode-app-core — 40 commits
• (repo) — 16 commits
• (root) — 13 commits
• src/cli — 8 commits
• docs/images — 7 commits
• crates/jcode-sdk — 6 commits
• crates/jcode-harness-api-server — 5 commits
• crates/jcode-provider-core — 5 commits
• crates/jcode-provider-anthropic-runtime — 4 commits
• crates/jcode-setup-hints — 4 commits
• crates/jcode-applet-types — 3 commits
• crates/jcode-provider-openai — 3 commits
• crates/jcode-storage — 3 commits
• docs/BROWSER_HANDOFF_ACCEPTANCE_2026_09_19.md — 3 commits
• scripts/benchmark_browser_handoff.md — 3 commits
• .github/workflows — 2 commits
• crates/jcode-provider-grok-build-runtime — 2 commits
• crates/jcode-provider-openrouter-runtime — 2 commits

• fix: Fix cache notification regression fixture type inference
• fix: Fix reset hint test buffer extraction scope
• fix: Merge pull request #1319 from zipadoodlez/fix/wrapped-row-copy-map
• fix: Merge pull request #1518 from takumi3488/fix/mcp-dead-server-hang
• fix: Merge pull request #1537 from alecuba16/fix/telemetry-tui-test-hermeticity
• fix: Merge pull request #1540 from alecuba16/fix/alignment-alt-chord-hint
• fix: Merge pull request #1541 from alecuba16/fix/benchmark-resume-cache-poisoning
• fix: Merge pull request #1542 from alecuba16/fix/ambient-cache-test-hermeticity
• fix: Merge pull request #1544 from alecuba16/fix/upstream-mcp-lifecycle
• fix: Merge pull request #1545 from alecuba16/fix/upstream-reload-tests
• fix: Merge pull request #1546 from John8a/fix-1329-antigravity-endpoint
• fix: fix(anthropic): bump Claude CLI user agent to 2.1.280
• fix: fix(anthropic): honor scoped OAuth catalog over legacy plan gate
• fix: fix(anthropic): isolate API and OAuth model catalogs and route availability
• fix: fix(anthropic): isolate API and OAuth model catalogs and route availability
• fix: fix(anthropic): refresh auth routes independently and shape Opus 5.5 requests
• fix: fix(anthropic): refresh auth routes independently and shape Opus 5.5 requests
• fix: fix(anthropic): reshape model fallback requests and preserve bound thinking
• fix: fix(antigravity): address greptile review — override-aware project lookup, endpoint validation, catalog invalidation
• fix: fix(antigravity): don't abort project lookup on a non-JSON loadCodeAssist response
• …and 280 more

• Containers 0 added · 0 removed · contexts 0 added · 1 removed · edges 0 added · 0 removed

• python

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

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.