Create PR now understands multiple GitHub accounts

The Create Pull Request flow was rebuilt around account-aware GitHub routing. Kaji can parse GitHub remotes, discover the right account context, and show the selected account directly inside the PR modal instead of assuming every repo belongs to the same identity.

• Added GitHubAccount, GitHubAccountParser, GitHubAccountService, and GitHubRemoteURLParser
• Added CreatePRGitHubAccountField so the PR modal shows the account being used
• Refactored CreatePRModal into context, presenter, and chrome components
• Added PullRequestBranchNameSlug for cleaner generated branch names
• Added tests for GitHub account parsing and PR palette behavior

Agent instructions load without blocking the UI

Agent instruction discovery is now asynchronous, error-aware, and stricter about which directories it scans. Opening the instructions panel no longer has to stall while the app walks the workspace.

• Added AgentInstructionDocument, AgentInstructionDiscovery, and AgentInstructionPanelState
• Added AgentInstructionsPanel loading and error states
• Added directory filtering so generated and dependency folders are ignored
• Added Ask palette entries for opening agent instructions
• Added AgentInstructionDiscoveryTests

Shared modal components got cleaner

The command modal and form layout pieces were extracted into reusable components, which keeps future modal flows from piling more state and layout code into the main window.

• Added KajiCommandModalShell and KajiFormSection
• Moved modal coordination through KajiModalCoordinator and KajiModalRoute
• Simplified MainWindow modal presentation paths
• Bumped Kaji to 0.3.3

Agent activity has a proper bridge into the app

Kaji now has a dedicated bridge for turning agent runs, provider activity, and notification context into app-level activity state. This makes the sidebar and navigation paths less dependent on scattered provider-specific assumptions.

• Added KajiAgentActivityBridge for mapping agent state into app activity
• Added KajiAgentActivityContextResolver and KajiAgentRunSummary
• Added AgentProviderCatalog as the central provider source
• Updated notification normalization and navigation for agent activity routes
• Added KajiAgentActivityBridgeTests and notification routing tests

Changed-file rows are easier to read and reuse

The VCS tab now separates changed-file presentation from the larger tab view. Rows understand their presentation mode directly, making file lists cleaner in regular VCS views and diff-focused contexts.

• Added VCSPresentationMode
• Extracted VCSChangedFileRow from VCSTabView
• Updated diff viewer tab creation and changed-file routing
• Added AppState diff viewer tests
• Bumped Kaji to 0.3.2

Browser control moved from CEF to native WebKit

Kaji's browser surface was migrated away from the embedded CEF/Puppeteer stack to a native WebKit-based view. The app keeps the in-app browser workflow, but drops a large amount of Chromium runtime packaging complexity.

• Migrated browser panes and controller actions to native WebKit infrastructure
• Removed CEF bridge sources and CEF runtime install validation scripts
• Updated browser screenshot, read-page, dialog, navigation, and device-profile paths
• Kept browser automation anchored to Kaji-owned browser sessions
• Updated browser architecture documentation

Browser MCP became a packaged tool surface

The browser MCP infrastructure was refactored into a broader tool catalog with a packaged install path. Browser actions are now described through dedicated command, action, target, and resource locator layers.

• Added KajiBrowserControlBroker, command registry, action aliases, and target arguments
• Added capture, diagnostic, file, interaction, and navigation action modules
• Added KajiBrowserMCPResourceLocator and KajiBrowserMCPInstallService
• Updated coding-agent browser environment wiring
• Added tests for browser MCP installation

Release packaging got smaller and safer

The release scripts were updated for the WebKit migration, and the shipped app rpath was fixed so packaged framework loading behaves correctly in the release artifact.

• Removed CEF runtime installation from the release path
• Updated build-release.sh and smoke-release-app.sh
• Added SwiftRunBundleLauncher updates for packaged app launching
• Fixed the release app framework rpath
• Bumped Kaji to 0.3.1

The editor moved to a bundled Monaco runtime

Kaji's native editor infrastructure was replaced with a bundled Monaco runtime built through Vite. This gives the app a more capable code-editing foundation while keeping the runtime packaged inside Kaji resources.

• Migrated MonacoEditor to a Vite-built runtime bundle
• Added bundled Monaco assets and worker files under Kaji resources
• Removed the older native editor language infrastructure
• Added Monaco asset server, first paint, mapper, model input, and reveal policy tests
• Added build-monaco-runtime.sh and integrated it with setup/release scripts

Open files in your preferred external IDE

Kaji now has first-class external IDE selection and opening services, so files can move from Kaji into the editor you actually want to use without hardcoded one-off paths.

• Added ExternalIDE model support
• Added IDE selection and file opening services
• Updated app state and tab routing for external editor handoff
• Added tests around Monaco and external editor behavior
• Bumped Kaji to 0.3.0

Custom providers now validate their keys before you trust them

The Kaji Agent custom provider flow now validates Azure-style custom provider keys and shows the validation state in settings. Bad provider setup should be caught earlier, with clearer feedback before an agent run fails later.

• Added KajiAgentCustomProviderValidation model support
• Added KajiAgentCustomProviderValidationStatusView
• Updated custom provider editor, row, and settings section with validation state
• Updated KajiAgentStore to request and surface provider validation
• Added Swift tests for custom provider validation

Runtime-side provider validation was split into focused modules

The TypeScript runtime side now separates provider config, secrets, types, and validation logic, making the custom-provider path easier to test and extend.

• Added custom-provider-validation, custom-provider-secrets, and custom-provider-types modules
• Updated runtime RPC types and client/server handling for validation requests
• Added runtime tests for custom provider validation
• Bumped Kaji to 0.2.9

Agent timelines can handle long conversations better

The agent transcript view was rebuilt around virtualized rows, height indexes, visible range policy, and row stores. Long-running agent sessions should scroll more smoothly without forcing every transcript row to stay mounted.

• Added KajiAgentTimelineRow, row store, height estimator, height index, and visible range policy
• Added KajiAgentVirtualTimelineView and row height reading
• Added timeline flattener and row spacing policy
• Improved scroll lock behavior for active agent output
• Added extensive tests for timeline virtualization and scrolling

Transcripts render richer markdown and collapsible tool output

Agent output now has a richer markdown parsing and rendering pipeline, including code blocks, long text handling, streaming markdown, thinking rows, and accordion-style disclosure rows for dense output.

• Added KajiAgentMarkdownModels and KajiAgentMarkdownParser
• Added KajiAccordionItem, KajiAgentCodeBlockView, KajiAgentLongTextView, and streaming markdown views
• Added inline semantic parsing for transcript text
• Added tool call rows, tool output views, and grouped tool headers
• Added markdown parser and inline parser tests

Kaji Agent custom providers arrived

Custom provider configuration was added to both the native app and the agent runtime, including Azure OpenAI deployment discovery and normalized provider config handling.

• Added KajiAgentCustomProvider models, auto-match behavior, enums, and model configuration
• Added custom provider settings editor, model editor, rows, and section UI
• Added runtime custom provider config normalization and model registry support
• Added Azure OpenAI deployment discovery tests
• Bumped Kaji to 0.2.8

User command shortcuts landed in the command surface

Kaji now supports user-defined command shortcuts that can be parsed, validated, previewed, resolved, and launched from the Ask palette. The shortcut reference UI also gained a dedicated section so custom commands are easier to discover.

• Added UserCommandShortcut models and resolved command templates
• Added parser, resolver, validator, preview builder, argument binder, and store services
• Added user command shortcut settings rows and form UI
• Added Ask palette integration for user command shortcuts
• Added parser, resolver, store, template, and palette tests

Parent Agent sessions keep their tab scope

Parent Agent state now preserves tab scope and session identity more carefully across workspace snapshots. Agent run details are also persisted in the V2 snapshot path.

• Updated AppState and workspace snapshot handling for Parent Agent tab scope
• Persisted agent run details in V2 snapshots
• Updated OpenCode plugin runtime handling
• Added AppStateParentAgentTests and AgentRunPersistenceV2Tests

Browser lifecycle cleanup got sturdier

The CEF browser runtime received lifecycle and cleanup hardening so browser sessions recover and discard inactive work more predictably.

• Improved KajiBrowserRuntimeCoordinator behavior
• Added KajiCEFProfileRecovery tests
• Added browser inactive discard policy coverage
• Updated browser controller registry and pane cleanup paths
• Bumped Kaji to 0.2.7

Agent tasks can float above the conversation

A new floating task button and popover make active agent tasks easier to reach while you are reading or scrolling through a long transcript. The task UI is backed by explicit state and tests instead of being hidden inside the main agent view.

• Added KajiAgentFloatingTaskState
• Added KajiAgentFloatingTaskButton
• Updated KajiAgentHome, message rows, turns, and tool groups for the floating task flow
• Added KajiAgentFloatingTaskStateTests
• Documented the floating task and scroll-lock plan

Timeline updates are coalesced before hitting the UI

Agent transcript updates now pass through a coalescer, reducing noisy UI churn during streaming output and tool updates. Scroll lock handling was also hardened for stop-loader and transcript glitches.

• Added KajiAgentTimelineUpdateCoalescer
• Updated KajiAgentScrollCoordinator and KajiAgentScrollLockPolicy
• Improved tool timeline application behavior
• Added tests for update coalescing, scroll lock policy, abort reconciliation, and transcript virtualization
• Bumped Kaji to 0.2.6

Agent runtime tool surface expanded with domain-specific host tools

Kaji's agent runtime tool surface was restructured from a monolithic host tool registry into a modular per-domain tool architecture. Each domain gets its own tool module with dedicated type definitions, making the bridge easier to extend and maintain.

• Added KajiAgentBasicHostTools and definitions for core host operations
• Added KajiAgentCodeGraphHostTools and definitions for CodeGraph query, status, and visualization
• Added KajiAgentCodeGraphStatusTool for dedicated CodeGraph status checking
• Added KajiAgentFFFHostTools and definitions for FFF-based file and text search tools
• Added KajiAgentWorkspaceContext and KajiAgentWorkspacePathResolver for workspace-aware tool execution
• Added KajiAgentHostToolCatalog for unified registration and discovery across all host tool domains
• Added KajiAgentSubagentInlineLayout and KajiAgentTodoIndicator for inline subagent rendering and todo display
• Added KajiAgentTranscriptToolUpdater for updating tool call transcript entries
• Updated coding agent shim script paths for the new tool architecture

Native addon staged and validated in release builds

The built Kaji Agent Runtime bundle (kaji-agent-runtime.mjs) is now staged as a native addon inside the Xcode project before the Swift build, and validated for presence and integrity. The release workflow includes it in the release artifact.

• Added stage-kaji-agent-native-addon.sh to copy and validate the bundled runtime
• Updated build-release.sh to stage the native addon before the Swift build
• Updated the release workflow to include the native addon in the release artifact
• Updated smoke-release-app.sh to validate the native addon inside the bundled app

Comprehensive test coverage for tool runtime

36 new test files were added across the agent runtime tool surface, covering timeline appliers, extension request parsing, URI resolution, pending RPC handling, error gating, readiness controllers, runtime state snapshots, todo write/update, and workspace path resolution.

• Added KajiAgentAssistantTimelineApplierTests, KajiAgentToolTimelineApplierTests, KajiAgentTranscriptRestorerTests
• Added KajiAgentExtensionRequestParserTests, KajiAgentHostURIResolverTests, KajiAgentPendingRPCTests
• Added KajiAgentRuntimeErrorGateTests, KajiAgentRuntimeReadinessControllerTests, KajiAgentRuntimeStateSnapshotTests
• Added KajiAgentTodoWriteUpdateTests, KajiAgentWorkspacePathResolverTests
• Bumped Kaji to 0.2.5

Agent runtime readiness gated properly

KajiAgentReadiness was added as a first-class model with ready, notReady, and error states. The runtime locator was significantly reworked with a dedicated cache layer (KajiAgentRuntimeLocatorCache) to avoid repeated filesystem scans. Bun version detection was extracted into its own testable service.

• Added KajiAgentReadiness model with explicit state tracking
• Added KajiAgentRuntimeLocatorCache to cache runtime location between checks
• Extracted KajiAgentBunVersion service with dedicated tests
• Added tests for AIProviderExecutableLocator, KajiAgentBunVersion, and KajiAgentRuntimeLocator
• Added PmsetBatteryLidCloseSleepManager and SleepPreventionBatteryLidCloseController tests

Service extraction from the monolithic store

Agent service helpers were extracted out of the monolithic store into focused services: AgentComposerCompletionProvider for completion handling, KajiAgentTextExtractor for text extraction, and expanded KajiAgentHostToolRegistry with extraction helpers. The agent control panel, home view, message row, sidebar history, task tools, and todo panel were refactored to use these extracted state objects.

• Extracted AgentComposerCompletionProvider for completion handling
• Extracted KajiAgentTextExtractor for text extraction from agent responses
• Expanded KajiAgentHostToolRegistry with tool extraction helpers
• Added tool output preview and agent control panel helpers
• Refactored KajiAgentHome, KajiAgentMessageRow, KajiAgentSidebarHistorySection, KajiAgentTaskToolView, and KajiAgentTodoPanel

Release and notification polish

Notification destination rows were polished with spinner support during test sends and clearer success/failure feedback. The release pipeline was updated with build-release.sh and smoke-release-app.sh improvements for the new agent runtime build step.

• Updated notification destination and route rows with spinner during test sends
• Added presence effect to notification badges
• Refined badge feedback styles and segment border display
• Updated build-release.sh and smoke-release-app.sh for runtime validation
• Bumped Kaji to 0.2.4

Process.WaitUntilExit timeouts prevent UI hangs

This release addresses a class of main-thread blocking issues where Process.waitUntilExit() calls across the codebase could hang the UI indefinitely. Every Process.waitUntilExit() call now has a timeout, and blocking process operations are offloaded from the main thread using DispatchQueue.global().sync.

• Added timeoutSeconds to every Process.waitUntilExit() call across 14 files
• Patched AIProviderExecutableLocator, AIProviderInstaller, AIUsageTokenReader, AdminPowerCommandRunning
• Patched AgentEditProcessRunner, AgentVerificationRunner, CodingAgentCommandRunner, MCPRuntimeCommandRunner
• Patched OpenCodeAgentHistory, CodingAgentProcessPatternKiller, FileTreeService, GitProcessRunner, GitWorktreeService
• Offloaded blocking Process work from main thread in 8 services using DispatchQueue.global().sync

Agent runtime availability improved

The KajiAgentRuntimeLocator and KajiAgentStore were hardened to handle runtime unavailability more gracefully, preventing the agent panel from hanging when the runtime process can't be reached.

• Improved graceful degradation when Kaji Agent Runtime is unavailable
• Prevented agent panel hangs on missing runtime
• Bumped Kaji to 0.2.3

Three visual modes: Solid, Translucent, and Glass

The app window background system was rebuilt around three visual modes. Solid mode preserves the traditional opaque look. Translucent mode makes windows and surfaces semi-transparent. Glass mode uses macOS 26's Liquid Glass APIs with Ghostty background-blur support for a modern frosted-glass effect when available, with graceful fallback to Translucent on older systems.

• Added AppearanceMode enum (Solid, Translucent, Glass) with capability gating for macOS 26
• Added AppearanceModeResolver that handles accessibility reduce-transparency overrides
• Added KajiAppearanceContext environment value threaded throughout the view hierarchy
• Added KajiControlSurface and TranslucentSurface wrappers for glass-aware component backgrounds
• Applied glass surfaces to browser toolbar, sidebar, inputs, selects, switches, segmented pickers, buttons, and icon toggles
• Added Ghostty glass terminal settings: background-opacity, background-blur, background-opacity-cells
• Added TerminalGlassBlurMode with Regular Glass and Clear Glass options

Kaji Agent Runtime build pipeline established

A dedicated build script (build-kaji-agent-runtime.sh) bundles the Kaji Agent Runtime TypeScript source into a single .mjs file using Bun, which is then embedded into the Kaji app resources. The release pipeline invokes this step before the Swift build.

• Added build-kaji-agent-runtime.sh for bundling the agent runtime with Bun
• Integrated agent runtime build into build-release.sh
• Added gitignore exclusion for the bundled kaji-agent-runtime.mjs artifact
• Added Bun installation step in the release workflow

FFF host search tools and permission modes for agents

Agents can now invoke FFF-backed file and text search tools through the Kaji host bridge, enabling fast indexed search without traversing the filesystem manually. Agent permission modes and zlob-backed glob matching were added for pattern-based file authorization.

• Added FFF host search tools for agent file and text search
• Added agent permission mode tracking for operation authorization
• Added zlob-backed glob matching for pattern-based agent file access

Native diff parser replaces SwiftyDiff adapter

The SwiftyDiff-backed parser was replaced with a fast native patch parser that tracks hunk line numbers, additions, deletions, and inline change segments. Diff views now render rows directly with cached attributed lines, and large diffs are rendered in chunks to avoid performance issues.

• Added a native fast diff parser replacing SwiftyDiff adapter
• Added DiffRenderPlan with chunked unified and split view support
• Added row indexing, line metrics, and split row pairing
• Improved large diff performance with cached attributed lines and backgrounds
• Added tests for render planning, inline diff segments, and split pairing

CI/CD infrastructure overhaul

The release pipeline was split into macOS 15 (deps build) and macOS 26 (Swift build) stages. Zig 0.16.0 auto-download was added for zlob builds, and CEF helper executable bits are restored after artifact download. SwiftUIIntrospect was added as a dependency for SwiftUI window introspection.

• Split release workflow into macos-15 deps and macos-26 Swift build jobs
• Added Zig 0.16.x auto-download in build-zlob.sh when missing
• Fixed CEF helper and zlob executable bits after artifact download
• Fixed ghostty.h inclusion in native deps artifact
• Added SwiftUIIntrospect dependency (v26.0.1)
• Bumped Kaji to 0.2.2

Chunked agent run persistence prevents bloat

The old single-file agent-runs.json approach could balloon into massive save payloads as changed-file lists grew. The persistence layer was rebuilt with a structured directory layout, chunked file storage, and a debounced actor-based writer. Legacy files are automatically migrated and backed up.

• Replaced monolithic agent-runs.json with structured AgentRuns/ directory layout
• Added index.json holding run metadata with compact changed-file previews (first 20)
• Changed files stored in 200-file chunks under ChangedFiles/<run-id>/
• Legacy agent-runs.json files are automatically migrated and timestamp-backupd
• Added AgentRunPersistenceWriter actor with 450ms debounced writes

Changed file snapshot policy filters noise

A new filter caps stored changed files at 500 and excludes paths matching known generated or dependency directories (.git, .build, .next, .swiftpm, DerivedData, build, dist, node_modules), preventing agent run data from being overwhelmed by build artifacts.

• Added AgentChangedFilesSnapshotPolicy with configurable ignored path components and max count
• Filters out .git, .build, .next, .swiftpm, DerivedData, build, dist, node_modules paths
• Caps stored changed files at 500 per run
• App lifecycle flush ensures no data loss via AgentRunStore.flushPersistence() on terminate
• Bumped Kaji to 0.2.1

Coordinated motion system across the entire UI

A Pow-backed motion system was introduced with press, hover, selection, success, attention, and invalid change effects. New view modifiers (kajiPressEffect, kajiHoverEffect, kajiChangeFeedback) were applied across side panel toggles, overlays, editor mode switches, settings, sidebar, VCS, browser, workspace, and shared controls. All transitions respect reduced-motion preferences.

• Added KajiMotion with shared animation constants and Pow-backed change effects
• Added kajiPressEffect, kajiHoverEffect, and kajiChangeFeedback view modifiers
• Applied motion effects to side panels, overlays, editor modes, settings, sidebar, VCS, browser, and workspace
• All side panel toggles (VCS, file tree, browser, search, agent instructions, outline) now animate with blur + move transitions
• Added microinteraction research documentation

ps-based process snapshots with stricter classification

The agent process monitor now uses a ps-based snapshotter (CodingAgentPSProcessSnapshotter) that parses ps -axo output, enriched with thread count and memory data from the native kernel snapshotter. Process classification was tightened so generic runtimes (node, bun, Python, shell) require strong command markers to be classified as coding agents.

• Added CodingAgentPSProcessSnapshotter using ps -axo output
• Native kernel snapshotter now enriches ps results instead of being primary source
• Added strong marker requirement (/, ., or @) for generic runtime classification
• Added CodingAgentPSProcessSnapshotterTests and CodingAgentProcessClassifierTests
• Changed process panel icon from sparkles to cpu

Visual polish across the app

The main window panel identity system was refreshed so side panel changes animate consistently. Editor markdown view modes (code/preview/split) and the outline panel now use animated transitions. Search replace fields, disclosures, and notification controls received motion polish.

• Added SidePanelIdentity enum for consistent animated panel transitions
• Editor markdown view mode toggles animate with contentSwitchTransition
• Editor outline panel animates slide-in/out; rows have hover highlight
• Search replace field slides in with disclosure transition
• Notifications show success/failure feedback; test sends show spinner
• Toast notifications on worktree creation and language pack installs
• LogoCropper shows inline error messages instead of silent cancellation
• Bumped Kaji to 0.2.0

Coding agent processes read directly from the kernel

Kaji's agent process monitor moved from the old arguments-by-PID scan to a native proc_pidinfo-based snapshotter that captures executable paths, thread counts, memory bytes, and process state directly from the Darwin kernel, without spawning subprocesses on the main thread.

• Added CodingAgentNativeProcessSnapshotter using Darwin.proc_pidinfo for memory, thread count, and executable path
• Added CodingAgentProcessArgumentSnapshotter for per-PID args via proc_args
• Added CodingAgentProcessPatternKiller for pkill-based agent process termination with pattern matching
• Replaced the old CodingAgentProcessParser with structured process info and pattern-based killing
• Replaced sparkles icon with cpu icon across process monitor UI
• Added tests for argument snapshotter, pattern killer, and classifier behavior
• Bumped Kaji to 0.1.91

Browser automation now runs through Chrome DevTools by default

Kaji's in-app browser control now defaults to Chrome DevTools MCP over the embedded Chromium remote-debugging endpoint.

Agents still operate the browser inside Kaji, but the automation layer is closer to the browser protocol, with an allowlist around the tools that are verified against Kaji's CEF surface. Playwright is still available as a fallback through KAJI_BROWSER_PROVIDER=playwright.

• Added a Chrome DevTools browser automation provider for Kaji browser MCP
• Made Chrome DevTools the default browser provider
• Added session-scoped broker readiness and CDP endpoint waiting
• Hid unverified Chrome-only tools unless explicitly enabled
• Added open and close browser panel notifications so automation can bring the browser surface into view

Search moved to FFF

File search and project text search now run through an FFF-backed index instead of Kaji's older in-process file scan and ripgrep path.

Translation: the search path got a real engine. Less rummaging through the repo closet, more getting the result you asked for.

• Added FFFKit and a dynamic FFF search library loader
• Added shared FFF search indexes for file search and text search
• Replaced the old quick-open file index path with FFF-backed search
• Replaced project text search's ripgrep/fallback path with FFF-backed text search
• Limited cached FFF indexes and serialized index access to keep search memory and concurrency under control

Top bar monitors for ports and coding agents

Two new top bar popovers make it easier to see what is actually running on your machine while agents are working.

Kaji can now show listening ports and coding-agent processes without making you leave the app to run lsof, ps, and a tiny prayer.

• Added a Running Ports monitor with filtering, refresh, PID details, and confirmed SIGTERM kill actions
• Added an Agent Processes monitor grouped by provider
• Detects Codex, Claude Code, OpenCode, and Pi processes through agent definitions, executable names, and command markers
• Labels agent processes as active, detached, or orphaned based on process group and parent process state
• Added individual and grouped kill actions for visible agent processes

Editor loading and model policies got quieter

A big internal editor pass landed in this release, focused on making heavier workspaces less dramatic.

The editor now has more explicit policies for inactive resources, viewport math, cursor visibility, decorations, folds, language pairing, markdown scroll sync, and tab history. Not glamorous, but this is the type of plumbing that makes the app feel calmer.

• Added deferred editor loading and inactive editor resource budgets
• Added visual-line mapping, line-start indexes, viewport frame metrics, and scroll clamp behavior
• Added dedicated policies for decorations, cursor visibility, folded lines, undo behavior, language pairs, and markdown preview scroll sync
• Added indexed tab-area snapshots and richer tab history handling
• Added a large batch of model and service tests around editor, browser, search, tabs, ports, and agent processes

CEF and release polish

The CEF runtime installer is a little less wasteful now too. It can reuse a valid cached runtime/archive unless a refresh is explicitly requested. Small release-workflow thing, nice quality-of-life win.

• Reused cached CEF runtime archives when the embedded framework is already present and valid
• Kept REFRESH_CEF_RUNTIME as the explicit escape hatch for forcing a fresh runtime fetch
• Bumped Kaji to 0.1.9

Git commands move into Cmd+K

Kaji 0.1.8 turns the Ask palette into a more useful command surface for everyday Git work.

You can now run, preview, and confirm Git commands from inside Kaji instead of opening a throwaway terminal for every small repo operation.

• Added :git, :branch, :switch, and :checkout palette flows
• Added common Git entries for status, fetch, pull, push, branch list, log, and diff stats
• Added structured previews for status, branch list, commit log, stash list, diff stat, show, tag, and blame output
• Added confirmations for destructive commands like hard reset, clean, force push, and branch delete
• Blocked or redirected interactive Git flows that need a real terminal

Guided commits and generated messages

Commit creation now has a native Kaji flow.

Kaji can build an inventory from selected files, draft a commit message, optionally refine it through Kaji Parent Agent, and run the final commit through the native Git service.

• Added a native :commit flow in the Ask palette
• Added selected-file commit inventory and commit diff context
• Added generated commit-message drafting and optional Parent Agent refinement
• Added commit-message detail settings for fast, medium, or detailed output
• Added custom commit-message instructions in Settings

Native previews for more file types

Kaji can now open non-code files in native preview tabs instead of trying to treat every file like text.

That means images, PDFs, media, web/SVG files, documents, archives, 3D models, and QuickLook-backed files can stay inside the workspace while source files still open in the editor.

• Added native preview tabs for images, PDFs, audio/video, web/SVG, documents, archives, 3D models, and QuickLook fallback files
• Added preview tab state and workspace persistence support
• Added reveal-in-Finder and open-externally actions from previews
• Kept text and source files routed to the editor

Markdown preview grows up

Markdown preview moved to a richer bundled web-rendering pipeline while staying inside Kaji-owned resources.

The preview can now handle more realistic docs, reuse prewarmed surfaces, open local links through Kaji, and send external links to the system browser.

• Added bundled markdown-it, DOMPurify, KaTeX, Mermaid, and KaTeX fonts
• Added prewarmed Markdown preview surfaces over a shared WKWebView process pool
• Added local document-root media serving through scoped Kaji URL schemes
• Added local link routing through Kaji file opening
• Added external link handling through NSWorkspace
• Added editor and preview scroll synchronization support

Terminal settings get serious

Kaji now exposes a dedicated Terminal settings pane for Ghostty behavior.

Instead of hiding terminal behavior in config files, Kaji can manage shell integration, scrollback, clipboard policy, quick terminal sizing, link and file actions, and image memory from Settings.

• Added shell integration mode controls for detect, disabled, Bash, Fish, Zsh, Nushell, and Elvish
• Added prompt cursor, SSH compatibility, sudo terminfo wrapper, option-click cursor movement, option key mode, and mouse reporting settings
• Added battery optimized mode, scroll speed profiles, scrollback profiles, custom scrollback bytes, and telemetry settings
• Added clipboard read/write policy, bracketed paste protection, link previews, and file path actions
• Added quick terminal position, size, autohide, and image protocol memory settings
• Updated setup and docs toward upstream ghostty-org/ghostty

Release hardening

A couple of release-pipeline fixes landed with this release too, mostly to make the boring parts stay boring.

• Fixed GhosttyKit release cache validation
• Added PAT fallback for release workflow authentication

Packaged resources load from the right place

This bug-fix release hardens how Kaji finds its bundled resources in packaged builds. Browser MCP scripts, CodeGraph adapters, Parent Agent runtime files, language packs, icons, and other app assets now resolve through a shared app resource bundle lookup instead of assuming SwiftPM's development-time layout.

Translation: the app is much less likely to work perfectly in debug and then go looking for its socks in production.

• Added a shared Bundle.appResources lookup across app bundle, resource, executable, and loaded-bundle candidates
• Moved Browser MCP, CodeGraph, Parent Agent runtime, shortcut, and language-pack resource loading onto the packaged app resource bundle
• Updated the release workflow to smoke-launch the app during release builds

Browser profiles recover after a bad startup

Kaji now detects if the embedded Chromium profile was interrupted during startup, quarantines the old profile when needed, clears stale singleton lock files, and creates a clean profile for the next launch. If the browser profile gets haunted, Kaji moves it aside and keeps going.

• Added a CEF startup marker so failed browser startups can be detected on the next launch
• Removes stale SingletonCookie, SingletonLock, and SingletonSocket files before startup
• Quarantines failed CEFProfile directories with timestamped backups
• Marks browser startup complete after the embedded browser remains stable
• Added tests for stale lock cleanup, startup-marker cleanup, and failed-profile quarantine behavior

CEF and Sparkle signing hardened

This bug-fix release fixes packaged-browser signing for release builds. The release script now signs Sparkle, the Chromium Embedded Framework libraries, CEF helper apps, KajiHookClient, and the app bundle in a more deliberate inside-out order.

Basically: fewer mysterious release-only browser failures, more boring builds. Boring is good here.

• Added reusable release signing helpers with a default ad-hoc signing identity
• Signed Sparkle, CEF framework libraries, CEF helper apps, KajiHookClient, and the final app bundle
• Extended bundle validation to check CEF framework, helper app, and full app signatures
• Added a CEF log file under the browser profile for easier release debugging

Resource bundle layout cleaned up

Kaji_Kaji.bundle now lives only where the packaged app expects it: inside Contents/Resources. The validator also fails if the resource bundle accidentally lands at the app bundle root again.

• Removed the duplicate root-level resource bundle copy from release packaging
• Added validation for correct Kaji_Kaji.bundle placement
• Bumped Kaji to 0.1.5 build 535

Embedded browser startup fix

This hotfix repairs an embedded Chromium startup regression around the CEF message pump and browser view lifecycle.

Immediate CEF work now goes through a main-queue dispatch source, page and popup callbacks are safely marshalled to the main thread, and detached browser surfaces are marked inactive instead of being torn out from under SwiftUI.

Parent Agent streaming feels alive again

Live Parent Agent output now renders through a throttled streaming text view, auto-scrolls as long answers grow, and debounces persistence so every tiny text delta does not become a disk-write fire drill.

• Added ParentAgentStreamingText for smoother live assistant output
• Added live-tail auto-scroll while an answer is still incomplete
• Debounced streaming saves and added an explicit flush path
• Cached Node runtime lookup for faster Parent Agent startup checks
• Added launch and heartbeat timing logs for future diagnostics

The editor grew teeth

Kaji 0.1.3 is the release where the native editor stops being a side quest and becomes a real part of the AI coding workflow.

Language packs now drive syntax, comments, brackets, folding metadata, snippets, formatter metadata, Tree-sitter metadata, TextMate metadata, and LSP metadata.

• Bundled language support for C, C++, JavaScript, TypeScript, JSON, JSONC, Python, Shell, SQL, and Swift
• Installable Ruby and Zig language packs with integrity validation
• Go to Symbol, Go to Line, editor outline, status bar, cursor state, and viewport state
• Inline AI edit flow with provider/model choice, diff preview, proposal editing, and apply

Diagnostics, search, and review mode

This release adds LSP diagnostic plumbing, a Problems panel, project-wide search/replace, and a much more capable VCS review surface.

The diff viewer can now review all changes, show file headers, mark files viewed, comment on files/hunks, stage or unstage from the header, expand hunk context, and lazy-load large diff bodies so Kaji does not try to swallow the whole repo at once.

• Added global search and replace with confirmation preview
• Added Problems grouped by file with error and warning counts
• Added all-changes diff review, file comments, and hunk context controls
• Improved drag reordering and fixed long-running memory retention across editor, browser, graph, terminal, LSP, and Parent Agent surfaces
• Replaced the vendored Pi mono repo with KajiParentAgentRuntime using pinned Pi npm packages

History resume got less haunted

Kaji now handles provider-history resumes more carefully, especially when routing from Ask into existing terminal sessions.

The resume path was moved off the blocking path, history annotations were resolved more reliably, and the default terminal resume flow was tightened so old sessions do not drag the UI into a swamp.

• Resolved history annotations before dispatch
• Launched history resumes asynchronously
• Skipped expensive session scans for history resumes
• Prevented a resume seed update loop
• Separated Codex resume prompt behavior from other providers

Browser persistence polish

Browser state now survives project switches more reliably, browser tabs compress better, and temporary Playwright MCP artifacts are ignored so the repo does not collect crumbs from browser automation.

• Preserved browser sessions across projects
• Made browser tabs responsive
• Removed temporary Ask hang diagnostics after the issue was narrowed

Provider-specific resume behavior

This release separates Codex resume prompts so Codex history sessions can be resumed without forcing the same prompt behavior onto every other provider.

Small release, important fix. The kind that saves you from asking why one provider is acting like another provider wearing a fake mustache.

• Separated Codex resume prompts from shared resume handling
• Bumped and published the Kaji 0.1.1 release package

Settings caught up with the new name

The app had already become Kaji, and this release moves the remaining Droid settings paths and labels into the Kaji world.

Bookmarks also got a small usability fix so pressing Enter resumes saved sessions instead of making you poke around like it is 1998.

• Migrated Droid settings to Kaji naming
• Fixed saved bookmark resume on Enter
• Added browser devtools support
• Switched browser devtools to the native path

The rebrand release

Droid becomes Kaji in this release. The name changed because the product had moved beyond a terminal app and into a native control surface for steering AI coding work.

Kaji also gains the browser-control foundation needed for agents to use an embedded browser without launching a random external Chrome window.

• Renamed the product from Droid to Kaji across app surfaces and release packaging
• Added an MCP server control panel
• Added Playwright-backed browser MCP support over Kaji browser control
• Improved pointer affordances and hit areas
• Added a dedicated MCP footer icon

Browser inside the command center

Droid gets an embedded Chromium browser side panel, plus the first serious round of browser-agent integration work.

This is the release where the browser stops being “open a separate thing somewhere else” and starts becoming a workspace surface agents can eventually use.

• Added embedded Chromium browser side panel
• Added browser control features with MCP integration
• Updated release packaging for bundled CEF
• Avoided duplicate release app rpaths
• Improved browser and agent integration fixes

Agent and workspace polish

• Added agent session bookmarks
• Fixed agent history titles
• Showed Droid resource usage
• Fixed macOS Tahoe chrome controls
• Enhanced notification handling with new policies and coalescing logic

Keep graph artifacts out of the repo

DroidCodeGraph now avoids dumping Graphify output into the target project repository. Graphs belong in Droid-managed extension storage, not as surprise confetti in your working tree.

• Prevented DroidCodeGraph repo-root output pollution
• Added CLI launcher installation state management
• Adjusted window traffic light layout behavior
• Merged the latest mainline fixes into the release path

Native code graph workflow

This release introduces the DroidCodeGraph extension, bringing Graphify-backed project graphs into the native app workflow.

The goal is to give agents and humans a better map of the codebase instead of sending everyone into the forest with a flashlight and good intentions.

• Added DroidCodeGraph extension support
• Implemented CodeGraph agent functionality
• Improved footer controls for graph runs and graph surfaces
• Packaged the first release of the graph workflow

Release resources in the right place

This hotfix fixes the packaged resource bundle location so release builds can find the resources they need after installation.

Tiny diff, big “why is the app acting different outside Xcode?” energy.

• Fixed packaged resource bundle lookup/location
• Published Droid 0.0.17 with the packaging fix

Release cache hardening

The GhosttyKit cache path gets more defensive in this release, including provenance verification and overwrite behavior during release builds.

In other words: fewer mystery terminal engines, more “yes, that is the artifact we meant to ship.”

• Verified GhosttyKit cache provenance
• Overwrote GhosttyKit cache during release when needed
• Published the corrected 0.0.16 package

Terminal engine alignment

The release pipeline now uses the Droid Ghostty fork by default, keeping terminal behavior aligned with the fork Kaji/Droid is built and tuned against.

• Switched release setup to the Droid Ghostty fork by default
• Published Droid 0.0.15 with the updated Ghostty source path

Less release-workflow wrestling

This release cleans up the path around cached GhosttyKit artifacts and makes the Homebrew cask update step safer when tap credentials are unavailable.

A few release attempts were needed here. The final result is less dramatic, which is exactly what you want from release automation.

• Used cached GhosttyKit in the release workflow
• Skipped cask updates safely when the tap token is missing
• Published the corrected Droid 0.0.14 package

Agent workflow upgrades

Droid gets a native Agent Instructions viewer, a configurable footer terminal, and fixes for parent-agent subagent output capture.

This is the release where the app starts showing more of the invisible context agents are actually using.

• Added native agent instruction viewing for project/global agent files
• Added configurable footer terminal support
• Fixed subagent terminal output capture
• Simplified the unsigned release workflow
• Fixed release workflow Xcode setup

Provider catalog refresh

This release refreshes the generated model catalog and ships Droid 0.0.12 with the updated provider metadata.

Not flashy, but model lists going stale is how settings pages start lying. This keeps them honest.

• Refreshed generated model catalog assets
• Updated release metadata for Droid 0.0.12

Shortcuts become data-driven

Droid gains a shortcut reference catalog backed by JSON configuration and supporting UI components.

That makes keyboard behavior easier to document, display, and evolve without turning every shortcut tweak into a treasure hunt.

• Implemented shortcut reference catalog with JSON configuration
• Refined sidebar menus and sidebar UI components
• Updated generated model catalog
• Cleaned README, license, docs, and app visuals
• Refactored code structure for readability and maintainability

Cleaner Pi signals

Pi permission requests and completion events are now separated so Droid can treat “please approve this” differently from “the task is done.”

Agents need nuance too. Otherwise every notification is just a tiny panic button.

• Separated Pi permission notifications from completion notifications
• Published Droid 0.0.10 with the notification fix

Parent Agent moves home

Droid home becomes a global surface instead of behaving like just another project tab.

Pi hook notifications and stop events were also fixed so the parent-agent loop can observe and control child work more reliably.

• Made Droid home global
• Fixed Pi hook notifications
• Fixed Pi stop events
• Published Droid 0.0.9

Parent Agent becomes a real surface

This release adds Parent Agent tab functionality and the related native UI needed to make parent-agent work visible inside Droid.

The orchestration layer also gets refreshed generated assets and improved task handling. The parent agent is no longer just lurking in the basement.

• Added Parent Agent tab UI components
• Updated parent-agent orchestration
• Improved the Parent Agent experience
• Updated generated parent-agent assets
• Bumped release build metadata

Find the runtime, launch the runtime

This hotfix tightens Parent Agent runtime lookup and refreshes the bundled runtime assets.

Very small release. Very important if the thing you are trying to launch is the thing that launches other things.

• Fixed Parent Agent runtime lookup
• Updated Parent Agent runtime assets
• Published Droid 0.0.7

Packaging guardrails

Release checks were updated and the Parent Agent runtime was refreshed again so the shipped app better matches the local development path.

• Updated release checks
• Updated Parent Agent runtime assets
• Published Droid 0.0.6

Parent Agent foundation

Droid gets its first serious Parent Agent foundation: a native shell, supervision loop, vendored runtime, build script, and orchestration path.

This is also where Pi joins the provider lineup, which is a pretty big deal for a 0.0.x release wearing a fake mustache.

• Added Parent Agent shell and supervision
• Vendored and bundled the Parent Agent runtime
• Added a build script for the Parent Agent runtime
• Refactored the coding-agent registry
• Added Pi as a coding agent provider
• Added DroidKit scripts and improved command-list rendering
• Improved Parent Agent attachment handling

The shortcut that stuck

Ask is remapped to Command K, making the main agent prompt feel like the central command surface it was becoming.

Small change, big muscle-memory consequences.

• Remapped Ask to Cmd+K
• Published Droid 0.0.4

Safer distribution and provider setup

This release adds the distribution release script and gates provider integrations on installed CLIs.

Droid now does a better job of not pretending a provider is ready when the CLI is nowhere to be found.

• Added distribution release script
• Gated provider integrations on installed CLIs
• Published Droid 0.0.3

Install path and first coat of paint

The Homebrew install path is corrected to use the droidkit cask, and the default theme colors get an early polish pass.

A release can be tiny and still make the app feel less like it escaped from a debug folder.

• Switched installation docs/scripts to the droidkit Homebrew cask
• Updated default theme colors
• Published Droid 0.0.2

From Muxy fork to Droid preview

This is the first public Droid release after the Muxy fork point. It establishes the app identity, packaging path, terminal workspace direction, and first AI-agent workflow surfaces.

A lot landed here because the app was becoming something very different: a native macOS workspace for coding agents, terminals, notifications, and review evidence.

• Added Droid brand assets, icon polish, and release setup
• Bundled Ghostty runtime resources and tuned terminal input, colors, typography, and responsiveness
• Added Ask command palette, inline routing annotations, history and skill routing, task recipes, and attachments
• Added Agent Mission Control transcripts, evidence, actions, and the keyboard Agent Command Center
• Replaced provider notification scripts with a native helper and improved Codex/OpenCode notification reliability
• Added notification routing, transparency controls, wake recovery, and resource monitoring
• Documented Homebrew install and reset release versioning to 0.0.1