Track important changes in AI Integration in IDEs, including capabilities, product updates, adoption signals, risks, and evidence worth continued monitoring.
This change fixes a persistence recovery failure by making Desktop only reuse local Workers it started for the same app version, while marking legacy or owner-missing connection records as stale and repairing them before replacement.
What ChangedThis change fixes a persistence recovery failure by making Desktop only reuse local Workers it started for the same app version, while marking legacy or owner-missing connection records as stale and repairing them before replacement.
Why It MattersDesktop users who upgrade the app are less likely to open with stale or missing workspace state, because the launcher now avoids attaching to an old Desktop-started local Worker from a prior version and instead triggers proper recovery against the current runtime. Technically, the fix writes owner/version metadata to the control-surface path and treats legacy/no-owner files as stale for Desktop launches, then repairs connection and lock state before replacement; continue watching for startup delays or unnecessary respawns caused by protocol-check and lock-file race conditions during upgrade flows.
Final score 81Confidence 961 evidence itemlocal Workercontrol-surface connection filesystem.capabilities.appVersionstartedBy--app-version
The PR introduces a remote-agent installer module that automatically checks for new agent package versions, downloads server-hosted zip bundles, and performs install/uninstall, verification, and immediate cache refresh for agents, commands, skills, rules, and MCP modules.
What ChangedThe PR introduces a remote-agent installer module that automatically checks for new agent package versions, downloads server-hosted zip bundles, and performs install/uninstall, verification, and immediate cache refresh for agents, commands, skills, rules, and MCP modules.
Why It MattersFor VS Code users and extension operators, CoStrict can now receive and apply new agent capabilities (skills, commands, rules, MCP integrations) with background auto-update and immediate in-process activation, reducing manual rollout steps and operator downtime. The implementation adds a singleton orchestrator with scheduled update checks (default 60 minutes, configurable), downloader validation, manifest/version checks, path-traversal-safe extraction, multi-window file locking, and exponential backoff on non-fatal failures; teams should watch whether silent background failures and lock expiry timing cause delayed recoveries or skipped updates in busy multi-window environments.
Final score 80Confidence 951 evidence itemRemoteAgentInstallerAgentDownloaderAgentInstallerInstallRecordManagerClineProviderchecksum validationfile lock
The PR changes Slack outbound message handling so markdown tables are rendered as native Slack Block Kit `table` blocks by default, with automatic fallback to the previous monospace section only when Slack table limits are exceeded or when a second table appears in the same message.
What ChangedThe PR changes Slack outbound message handling so markdown tables are rendered as native Slack Block Kit `table` blocks by default, with automatic fallback to the previous monospace section only when Slack table limits are exceeded or when a second table appears in the same message.
Why It MattersUsers and operators sending tables through agor to Slack now get clearer, properly aligned table rendering in common cases instead of crude code-block formatting, while oversized or repeated tables still remain readable through a controlled fallback path. Continue monitoring `blocks` payloads for Slack API schema errors and watch fallback-trigger behavior around wide/long/multi-table messages, because those edge cases are now the practical correctness boundary of the new rendering path.
Upgrades Copilot integration from one-off pattern-based starts to a session-aware flow by detecting existing Copilot sessions on disk, resuming them automatically, and wiring model/allow-all configuration into Copilot startup.
What ChangedUpgrades Copilot integration from one-off pattern-based starts to a session-aware flow by detecting existing Copilot sessions on disk, resuming them automatically, and wiring model/allow-all configuration into Copilot startup.
Why It MattersDevelopers and operators using Copilot inside agent-deck can continue ongoing AI coding sessions across restarts and pane boundaries without manual reinitialization, so long workflows keep context and reduce wasted prompt cycles; this is important to watch next because the new file-based discovery can still resume the wrong or stale session if session state files are incomplete, duplicated, or mismatched to the active project. The implementation also adds a config-based model/allow-all path (`~/.agent-deck.toml` and instance fields), so verify that non-standard install paths (`COPILOT_CONFIG_DIR`) and tmux environment propagation keep session IDs isolated per instance.
Final score 80Confidence 931 evidence itemagent-deckCopilot CLIsession-state/events.jsonlcopilot_hooks.gotmux~/.agent-deck.tomlCOPILOT_CONFIG_DIR
Introduces a dedicated Pi adapter path in claude-mem’s CLI adapter layer so Pi hook events are routed through worker-side handling and normalized to a consistent `pi` platform source.
What ChangedIntroduces a dedicated Pi adapter path in claude-mem’s CLI adapter layer so Pi hook events are routed through worker-side handling and normalized to a consistent `pi` platform source.
Why It MattersPi operators and integrators can now keep Pi event and observation flow inside the same claude-mem pipeline used by other platforms, so Pi-driven sessions become trackable and queryable without adding bespoke installer logic in this repository. The adapter accepts both Pi native and canonical input shapes, preserves existing hook output fields, and maps legacy `pi-mono` slugs to `pi`, which should reduce onboarding friction for teams testing the upcoming Pi extension package, but watch for schema drift between the future extension package and the worker contract because mismatched payload shapes could silently drop observations.
Final score 80Confidence 941 evidence itemclaude-memPiPlatformAdapterpi-monoplatform_source
The PR adds persistent column reordering for `DataGrid` by introducing a `useColumnOrder` hook and an optional `storageKey` prop, so reordered columns are saved to `localStorage`, validated on restore, and reapplied after reloads while preserving current defaults when storage is unavailable.
What ChangedThe PR adds persistent column reordering for `DataGrid` by introducing a `useColumnOrder` hook and an optional `storageKey` prop, so reordered columns are saved to `localStorage`, validated on restore, and reapplied after reloads while preserving current defaults when storage is unavailable.
Why It MattersUsers working in InsForge tables will keep their custom column layout after refresh, which reduces repeated manual reconfiguration and makes repeated review/analysis sessions faster and less error-prone; teams should monitor whether order persistence degrades when browser storage is cleared, unavailable, or contains outdated/malformed entries because the grid may revert to a default layout. Technically, this is implemented with a configurable `storageKey`, a reorder persistence path in `onColumnsReorder`, and key validation during restore.
Final score 80Confidence 931 evidence itemDataGridlocalStoragestorageKeyuseColumnOrdercolumn reorderingonColumnsReorder
Superset PR #4616 adds a dedicated `local` deployment profile with a `bun setup:local` entrypoint so a fresh worktree can boot a full local web/API/desktop stack using local Docker Postgres and Electric without requiring Neon/OAuth/Stripe/Resend/QStash/Upstash credentials. The local path also derives worktree-specific environment/state, while cloud and internal profiles keep strict env validation.
What ChangedSuperset PR #4616 adds a dedicated `local` deployment profile with a `bun setup:local` entrypoint so a fresh worktree can boot a full local web/API/desktop stack using local Docker Postgres and Electric without requiring Neon/OAuth/Stripe/Resend/QStash/Upstash credentials. The local path also derives worktree-specific environment/state, while cloud and internal profiles keep strict env validation.
Why It MattersDevelopers can bring up a runnable local Superset stack from a fresh clone without waiting for external service keys, which reduces onboarding friction and avoids blocking issue reproduction on missing credentials. The change adds a contributor-focused path (`bun setup:local`, local profile, local env derivation, and worktree-specific state) that routes nonessential integrations like OAuth, Stripe, and Resend to non-fatal paths in local mode instead of hard-failing startup. Continue watching whether local-mode permissiveness hides real integration regressions, and verify that per-worktree names remain unique enough as the number of cloned worktrees grows.
Final score 80Confidence 931 evidence itembun setup:localdeployment profile (local/cloud/internal/ci)Docker PostgresElectricSUPERSET_PROFILE
The PR fixes a path configuration bug where the research toolkit hardcoded VAULT_PATH to one developer’s local Obsidian vault, causing other users’ notes and generated obsidian:// links in /youtube, /research, /research-deep, and /notebooklm to be written to a non-existent location. It switches resolution to OBSIDIAN_VAULT_PATH via the shared get_required helper and updates .env/setup flow so the value is written in setup.sh for standalone CLI runs.
What ChangedThe PR fixes a path configuration bug where the research toolkit hardcoded VAULT_PATH to one developer’s local Obsidian vault, causing other users’ notes and generated obsidian:// links in /youtube, /research, /research-deep, and /notebooklm to be written to a non-existent location. It switches resolution to OBSIDIAN_VAULT_PATH via the shared get_required helper and updates .env/setup flow so the value is written in setup.sh for standalone CLI runs.
Why It MattersUsers running the research toolkit on any machine besides the contributor’s now save notes to their configured Obsidian vault correctly, so their research notes and generated obsidian:// deep-links are much less likely to break or disappear. This is achieved by deprecating the hardcoded vault path in favor of OBSIDIAN_VAULT_PATH plus get_required validation; next, monitor onboarding workflows where this variable is missing or not loaded in CI/automation because this change intentionally changes silent misrouting into explicit configuration failure.
Final score 79Confidence 981 evidence itemOBSIDIAN_VAULT_PATHVAULT_PATHget_requiredscripts/research/lib/config.pysetup.sh.env.example
The PR changes oh-my-pi’s GitHub Copilot auth flow so model calls carry `Copilot-Integration-Id: vscode-chat` and login stores a stable numeric GitHub user id in credentials, enabling existing dedup logic to match repeat logins instead of appending duplicates.
What ChangedThe PR changes oh-my-pi’s GitHub Copilot auth flow so model calls carry `Copilot-Integration-Id: vscode-chat` and login stores a stable numeric GitHub user id in credentials, enabling existing dedup logic to match repeat logins instead of appending duplicates.
Why It Mattersoh-my-pi users relying on Copilot credentials will get more stable model access and cleaner auth state because calls are routed under the correct Copilot integrator and repeated logins no longer proliferate duplicate credential rows. Previously, `ghu_` tokens could hit an incorrect scope and intermittently return `model_not_available_for_integrator`, while missing `accountId`/email made dedup impossible; adding the integration header and persisted user id addresses both. Watch whether non-standard Copilot token sources still bypass the expected scope behavior, and monitor cases where `/user` lookup fails (best-effort path is silent, so duplicates can still appear if that fetch is unavailable).
Final score 79Confidence 951 evidence itemGitHub CopilotCopilot-Integration-Idvscode-chatOAuthCredentialsGET /api.github.com/userupsertAuthCredentialForProvider
This change makes `truncateToWidth` accept legacy string ellipsis arguments in the TypeScript wrapper (while keeping enum/null values on the existing native path), so calls like `truncateToWidth(text, width, "")` from older/custom TUI renderers no longer hit the strict native enum conversion that could crash rendering.
What ChangedThis change makes `truncateToWidth` accept legacy string ellipsis arguments in the TypeScript wrapper (while keeping enum/null values on the existing native path), so calls like `truncateToWidth(text, width, "")` from older/custom TUI renderers no longer hit the strict native enum conversion that could crash rendering.
Why It MattersLegacy terminal UI apps and integrators using older `truncateToWidth` call patterns can keep rendering instead of crashing when width truncation is invoked with an empty-string ellipsis, reducing user-facing rendering failures in interactive sessions. The fix works by short-circuiting legacy string ellipsis inputs into wrapper-side handling while continuing to route enum/null inputs to the native path; next watch point is whether similar legacy value-shape mismatches exist in nearby native-bound TUI APIs that still assume strict enum types.
Final score 79Confidence 961 evidence itemtruncateToWidthTUI rendererTypeScript wrappernative addonEllipsis enumN-API
Serena now supports editing `.cue` projects through a dedicated CUE language server (`cue lsp`), with `Language.CUE` registration and platform-aware LSP setup so CUE symbols and cross-file references can be resolved inside the tool.
What ChangedSerena now supports editing `.cue` projects through a dedicated CUE language server (`cue lsp`), with `Language.CUE` registration and platform-aware LSP setup so CUE symbols and cross-file references can be resolved inside the tool.
Why It MattersDevelopers using Serena on CUE repositories can now get built-in language-aware editing features for `.cue` files (symbol trees and cross-file references), which should make configuration validation and navigation easier during development instead of relying on external tooling or manual inspection. The change depends on an external `cue` binary, so teams should monitor first-run download reliability, pinned-version compatibility with new `cue` releases, and startup behavior of the `workspace/configuration` handshake in large or constrained environments.
Final score 78Confidence 961 evidence itemSerenaCUEcue lspCueLanguageServerLanguage.CUEworkspace/configuration
This change restores Claude Code integration for Nix home-manager users by aligning the Nix install path with the non-Nix installer: required peon-ping hook and skill artifacts are now present and runnable so `/peon-ping-*` commands no longer fall through as unknown/unsupported.
What ChangedThis change restores Claude Code integration for Nix home-manager users by aligning the Nix install path with the non-Nix installer: required peon-ping hook and skill artifacts are now present and runnable so `/peon-ping-*` commands no longer fall through as unknown/unsupported.
Why It MattersOn Nix systems using the home-manager module, Claude Code slash commands for peon-ping and related prompt hooks now run instead of silently failing with `Unknown command`, so operators keep their chat-driven workflow functional without switching to a different install method; continue watching for future hook/skill additions that are not kept in sync between `install.sh` and Nix wiring, since that could reintroduce silent command misses. Technically, the PR updates `flake.nix` install logic to include missing script artifacts, wraps hook scripts to provide `python3` in minimal-path executions, and adds five skill symlinks under `~/.claude/skills` in `nix/hm-module.nix`.
Final score 78Confidence 951 evidence itemPeonPing/peon-pingNix home-managerflake.nixinstallPhasenix/hm-module.nixUserPromptSubmithook-handle-rename.shhook-handle-use.sh~/.claude/skills
This PR changes chat session behavior in Kilo-Org/kilocode so local sessions are no longer replaced when users start parallel work in the same repository. It introduces durable local session tabs in the sidebar and editor-tab surfaces, keeping multiple repository-scoped chats available from the existing workflow without switching context to Agent Manager.
What ChangedThis PR changes chat session behavior in Kilo-Org/kilocode so local sessions are no longer replaced when users start parallel work in the same repository. It introduces durable local session tabs in the sidebar and editor-tab surfaces, keeping multiple repository-scoped chats available from the existing workflow without switching context to Agent Manager.
Why It MattersDevelopers can continue multiple repository-level chats at once without one chat accidentally replacing another, so parallel investigation, coding, or debugging stays continuous instead of being disrupted by session loss. The change works by reusing the shared extension connection and restoring tab state per webview, with behavior aligned to Agent Manager session tabs; it should be monitored for regressions in session-state race handling during fast tab creation/import flows and cross-surface tab consistency.
The pull request makes the installer CLI actually execute the new server-beta runtime setup path and updates install-time behavior so runtime selection consistently controls setup actions, outputs, and status messaging.
What ChangedThe pull request makes the installer CLI actually execute the new server-beta runtime setup path and updates install-time behavior so runtime selection consistently controls setup actions, outputs, and status messaging.
Why It MattersDevelopers and operators running `claude-mem install` can now avoid accidental actions from `--help` and better judge whether their IDE and runtime environment is correctly configured before using it, because install output now reflects the actual selected runtime. Technically, the CLI now delegates `--runtime server-beta` to the dedicated server-beta setup path and normalizes post-install details such as URL, port, and status text; monitor for compatibility with the prerequisite #2544 merge, and verify rollback behavior and runtime messaging in real deployments to catch any future mismatch between worker and server-beta flows.
Final score 77Confidence 941 evidence iteminstall.tsclaude-mem installsetupServerBetaserver-beta runtimehelp flagautostart/message output
The PR updates the editor input flow so delete- and cut-related input events always clear React selection state, preventing the selection from staying visually selected after text removal.
What ChangedThe PR updates the editor input flow so delete- and cut-related input events always clear React selection state, preventing the selection from staying visually selected after text removal.
Why It MattersUsers deleting text in athas editor flows will see the selection collapse correctly after removal, so typing continues at the expected cursor point instead of acting on a visually stale selection state, and teams should keep monitoring cross-browser delete/cut edge cases for any remaining selection desync. In practice, the change avoids a misleading cursor/selection state that could cause accidental extra edits, especially where browser engines (notably WebKit) report inconsistent selection bounds; continued verification is needed on less-covered input paths and future DOM engine behavior.
Final score 76Confidence 931 evidence itemhandleInputuse-editor-textarea-input.tsdeleteContentBackwarddeleteByCutselection boundsWebKit
This change adds a corrected `/rollback` (`/undo`) flow in cc-connect that truncates the session JSONL by the requested number of turns and restarts the same session with `--resume`, replacing the previous behavior where truncation could be overwritten by a still-running agent.
What ChangedThis change adds a corrected `/rollback` (`/undo`) flow in cc-connect that truncates the session JSONL by the requested number of turns and restarts the same session with `--resume`, replacing the previous behavior where truncation could be overwritten by a still-running agent.
Why It MattersFor operators and developers who use cc-connect sessions, a mistaken turn can be removed and re-run without corrupting or recreating the session, so recovery during long conversational workflows is faster and less disruptive. The implementation now prevents overwrite races by stopping the agent before truncation and then resuming with reduced context; watch for rollback-triggered races with concurrent writes and whether resume integrity holds when truncation happens near high message throughput.
Final score 76Confidence 921 evidence itemcc-connectrollbackundoJSONLsession history--resumeagent process
Release v0.13.5 makes web and remote workspace users able to upload and download files and folders directly from the file tree through streamed transfers, with no file-size cap and a unified progress dialog that supports cancellation.
What ChangedRelease v0.13.5 makes web and remote workspace users able to upload and download files and folders directly from the file tree through streamed transfers, with no file-size cap and a unified progress dialog that supports cancellation.
Why It MattersWeb and remote workspace users can transfer large files and folders directly from the file tree without manual export/import steps, which cuts operational friction and makes collaboration on bigger artifacts practical and faster. The update also hardens the same transfer path with streaming behavior and centralized progress/cancel handling plus stricter upload and zip validation, so teams should monitor cancellation correctness, large-transfer stability, and whether the stricter checks produce false positives for legitimate archives.
Athas v0.7.0’s primary change is a core editor backend migration: the release replaces the legacy overlay editor surface with Monaco and routes editor command/settings behavior through that engine, signaling a move to a single editing implementation.
What ChangedAthas v0.7.0’s primary change is a core editor backend migration: the release replaces the legacy overlay editor surface with Monaco and routes editor command/settings behavior through that engine, signaling a move to a single editing implementation.
Why It MattersDevelopers using Athas should get a more consistent editing experience from v0.7.0 because the editor now runs through a single Monaco backend, which is likely to reduce UI/interaction inconsistencies and make behavior for common actions (commands, settings, cursor/search flows) more predictable. Watch for regressions in less common editor workflows, especially custom extensions, Vim-mode behavior, and large-file performance while the old overlay-based assumptions are fully retired.
Final score 75Confidence 911 evidence itemMonaco editorlegacy overlay editor stackeditor command routingeditor engine switchAthas IDE
The PR relocates the concrete orchestration implementation from `ClientCore` in `_core.py` to `Session` in `notebooklm/_session.py`, and converts `_core.py` into a compatibility re-export shim for legacy private imports.
What ChangedThe PR relocates the concrete orchestration implementation from `ClientCore` in `_core.py` to `Session` in `notebooklm/_session.py`, and converts `_core.py` into a compatibility re-export shim for legacy private imports.
Why It MattersDevelopers and integrators relying on internal notebooklm behavior can keep legacy private flows working while the team starts using a single canonical session implementation path, which reduces accidental breakage when making internal changes. Public behavior is unchanged for `NotebookLMClient`, so immediate user-facing risk is low, but teams should continue watching for remaining private imports to `_core` and any monkeypatch-dependent paths that could diverge as future refactors move fully to the new layering.
Final score 74Confidence 981 evidence itemSessionClientCore_core.py_session.pyNotebookLMClientmonkeypatch
This PR adds new Serena tools (`completion`, `hover`, `get_diagnostics`, `inlay_hints`) so AI agents can inspect symbol members, documentation, and diagnostics through the language server interface across Java, TypeScript, Python, and Rust; manual testing confirms completion/hover/diagnostics behavior for those languages, while inlay hints return empty results in Java and TypeScript.
What ChangedThis PR adds new Serena tools (`completion`, `hover`, `get_diagnostics`, `inlay_hints`) so AI agents can inspect symbol members, documentation, and diagnostics through the language server interface across Java, TypeScript, Python, and Rust; manual testing confirms completion/hover/diagnostics behavior for those languages, while inlay hints return empty results in Java and TypeScript.
Why It MattersDevelopers and AI coding assistants using Serena can get immediate symbol docs, completion suggestions, and diagnostic feedback while working, which can reduce API mistakes and shorten troubleshooting before running larger build/test steps. This depends on each language server’s capability support, so the remaining risk is uneven tool behavior—`inlay_hints` is still empty for Java/TypeScript in current tests—and operators should watch whether hint and diagnostics responses stay consistent as more languages or setups are used.
Final score 74Confidence 891 evidence itemSerenaLanguage Server Protocolcompletionhoverget_diagnosticsinlay_hintsAI agents
The PR introduces new VSCode settings controls so users can pick the active agent model and override model variants through dropdown UI in the Kilocode extension.
ContributionAdded user-facing dropdown configuration in VSCode settings for model and variant selection, replacing manual configuration paths for this choice in the extension.
ImpactDevelopers using the Kilocode VSCode extension can switch model setup directly from settings, which makes it easier to try different agent configurations without editing hidden files or retrying broken setups, so short experiment cycles become less error-prone. The change appears to centralize model/variant selection in editor configuration; operators should monitor compatibility with existing settings files, whether invalid variant values are handled clearly in UI, and whether the org-owned branch flow for visual-regression baseline updates keeps snapshots aligned.
Replaced free-text model/variant fields in KiloCode’s Agent Behavior settings with dropdown selectors, so users can switch agent model variants through a consistent UI control and persist those choices more reliably.
ContributionImplemented reusable model and variant dropdown components in the Agent Behavior settings page to replace plain-text entries, making model configuration a constrained, standardized selection flow with clearer defaults and permanent per-agent setting behavior.
ImpactVS Code users configuring KiloCode agents can now change model and variant with dropdowns instead of manual text typing, which reduces configuration mistakes and makes switching agent behavior faster in normal workflow; operators should watch for stale or unsupported selections in persisted settings after restart and verify that dropdown choices remain in sync with supported backend variants. Technically, the PR reuses existing model/variant UI primitives from other settings surfaces so selection format and state handling become consistent across the app.
The PR adds support for running WordPress agent skills from Gemini CLI and the Antigravity code editor, extending the tool integrations available to this project.
ContributionIntroduces new integration paths so agent-skills can be consumed through Gemini CLI and Antigravity, enabling direct skill invocation from those environments instead of requiring separate custom glue.
ImpactDevelopers using WordPress agent-skills can now use their existing Gemini CLI or Antigravity workflows without switching tools, which can reduce integration friction and setup overhead; continue tracking whether command routing, authentication, and execution behavior remain consistent in each client after adoption. The pull request appears to target broader ecosystem compatibility by adding external runtime surfaces, so downstream operators should watch for environment-specific permission mapping, credential handling differences, and regressions in skill discovery/execution across the two integrations.
This change adds a corrected `/rollback` (`/undo`) flow in cc-connect that truncates the session JSONL by the requested number of turns and restarts the same session with `--resume`, replacing the previous behavior where truncation could be overwritten by a still-running agent.
ContributionImplemented a concrete rollback persistence fix by ordering operations as stop-then-truncate-then-resume: the active agent is terminated before `TruncateSessionHistory` rewrites JSONL, and the session is restarted with `--resume` under the same session ID, making in-place context undo reliable.
ImpactFor operators and developers who use cc-connect sessions, a mistaken turn can be removed and re-run without corrupting or recreating the session, so recovery during long conversational workflows is faster and less disruptive. The implementation now prevents overwrite races by stopping the agent before truncation and then resuming with reduced context; watch for rollback-triggered races with concurrent writes and whether resume integrity holds when truncation happens near high message throughput.
One key change in this burst updates the Kilo VSCode integration to display a session-cumulative token counter, giving a running usage total instead of only per-message token counts.
Contributionadded session-level token accounting and UI display so users can read cumulative token usage in one place during an active editor session.
ImpactDevelopers using the Kilo VSCode extension can now monitor total token burn across a work session, which helps prevent surprise API spend growth and lets teams stop or adjust behavior before usage gets out of control. The change tracks tokens at the session scope and presents a rolling total in the VSCode view; monitor whether the counter resets correctly between sessions and whether long sessions maintain exact alignment with provider billing for all models.
This release change fixes a VS Code integration reliability issue by preventing the local CLI from entering reconnect flapping when the event stream is unavailable.
ContributionImplemented reconnect-behavior logic so the local CLI no longer repeatedly cycles reconnect attempts when the event stream drops, which stabilizes runtime behavior for VS Code users.
ImpactDevelopers using Kilocode in VS Code will encounter fewer disruptive reconnect loops and less UI instability when network or stream interruptions happen, so review/chat workflows stay usable instead of repeatedly losing momentum. The fix specifically targets the local CLI’s reconnect path during stream unavailability; continue watching whether recovery is still delayed after outages and whether any session state remains stale after reconnect.
Kilocode v7.3.5 includes a release fix that stops the VS Code local CLI from entering reconnect flapping when the event stream becomes unavailable.
ContributionAdds guard logic in the VS Code local CLI path to suppress repeated reconnect attempts when the event stream is down, preventing unstable reconnect churn during transient or prolonged stream outages.
ImpactVS Code users running local CLI sessions should see steadier behavior with far fewer reconnect storms and fewer session interruptions when the backend event stream drops, reducing wasted retries and operator resets during active work. This change likely works by tightening stream-availability handling in the reconnect path, so teams should monitor whether sessions recover cleanly after short network blips and whether any reconnecting clients remain in a partially active state.
The PR introduces a remote-agent installer module that automatically checks for new agent package versions, downloads server-hosted zip bundles, and performs install/uninstall, verification, and immediate cache refresh for agents, commands, skills, rules, and MCP modules.
ContributionImplemented end-to-end lifecycle management for remote agent packages in the CoStrict extension: version polling, secure zip download (redirect + checksum), atomic install/uninstall for five module categories, post-install integrity checks, fatal-error gating, retry policy, and hot-reload integration.
ImpactFor VS Code users and extension operators, CoStrict can now receive and apply new agent capabilities (skills, commands, rules, MCP integrations) with background auto-update and immediate in-process activation, reducing manual rollout steps and operator downtime. The implementation adds a singleton orchestrator with scheduled update checks (default 60 minutes, configurable), downloader validation, manifest/version checks, path-traversal-safe extraction, multi-window file locking, and exponential backoff on non-fatal failures; teams should watch whether silent background failures and lock expiry timing cause delayed recoveries or skipped updates in busy multi-window environments.
This PR changes chat session behavior in Kilo-Org/kilocode so local sessions are no longer replaced when users start parallel work in the same repository. It introduces durable local session tabs in the sidebar and editor-tab surfaces, keeping multiple repository-scoped chats available from the existing workflow without switching context to Agent Manager.
ContributionImplemented persistent local chat-tab session handling by reintroducing real per-webview local tabs and stabilizing session state across tab creation and import paths, so local sessions are not replaced when new parallel sessions are started.
ImpactDevelopers can continue multiple repository-level chats at once without one chat accidentally replacing another, so parallel investigation, coding, or debugging stays continuous instead of being disrupted by session loss. The change works by reusing the shared extension connection and restoring tab state per webview, with behavior aligned to Agent Manager session tabs; it should be monitored for regressions in session-state race handling during fast tab creation/import flows and cross-surface tab consistency.
This release addresses a Windows-specific bug in the KiloCode VS Code extension where indexing status updates could appear stale, by normalizing indexing path matching and preventing early SSE status events from being dropped.
ContributionPrevents incorrect stale indexing UI state on Windows by making directory matching case-tolerant and accepting status events that arrive before the extension receives initial config data.
ImpactWindows users of the KiloCode VS Code extension will get reliable indexing state updates, so they can trust when indexing is still running and avoid unnecessary retries or interface workarounds caused by seemingly frozen status indicators. Technically, the fix updates SSE directory matching for Windows path casing and changes event handling so pre-config payload indexing updates are preserved, which should reduce operator confusion during long indexing sessions; watch for residual mismatches after reconnects or mixed-case workspace paths.
KiloCode fixed a Windows-specific bug in the VS Code extension where indexing status could become stale, ensuring Settings and chat indicators continue to refresh as indexing progresses through case-aware path matching and improved status-event handling.
ContributionImplemented a Windows indexing-status fix that handles directory matching with case-aware paths and prevents status updates from being dropped when they arrive before the initial configuration payload.
ImpactWindows users of KiloCode’s VS Code extension can now track indexing progress reliably, so they are less likely to think indexing is stuck and take unnecessary remediation actions while indexing is actually running. The update also makes Settings/chat state updates align with real-time indexing events despite config-initialization timing, and should be monitored for any remaining event-loss behavior under high indexing throughput.
This PR strips redundant global npm install operations from the installation flow and CLI upgrade flow for OpenCode and KiloCode, shifting them away from system-wide package updates.
ContributionEliminated global package-management steps in both install docs and upgrade logic for OpenCode and KiloCode, reducing dependency on system-wide Node package state for onboarding and updates.
ImpactDevelopers using OpenCode or KiloCode can onboard and upgrade with fewer environment-level surprises, because they no longer have to rely on global npm package updates during setup. This reduces the chance of setup failure on machines with restricted permissions or pre-existing global package conflicts, while making install/upgrade behavior more predictable for CI and team-managed environments. Watch whether any downstream scripts or docs still assume global npm changes, since that could reintroduce hidden setup requirements.
This change restores Claude Code integration for Nix home-manager users by aligning the Nix install path with the non-Nix installer: required peon-ping hook and skill artifacts are now present and runnable so `/peon-ping-*` commands no longer fall through as unknown/unsupported.
ContributionIt fixes a concrete runtime-integration gap in the Nix packaging by adding the missing hook script and wrapping hook executables for `python3`, and by registering peon-ping skills in `home.file`, which makes Claude Code command discovery and hook invocation work correctly on Nix paths.
ImpactOn Nix systems using the home-manager module, Claude Code slash commands for peon-ping and related prompt hooks now run instead of silently failing with `Unknown command`, so operators keep their chat-driven workflow functional without switching to a different install method; continue watching for future hook/skill additions that are not kept in sync between `install.sh` and Nix wiring, since that could reintroduce silent command misses. Technically, the PR updates `flake.nix` install logic to include missing script artifacts, wraps hook scripts to provide `python3` in minimal-path executions, and adds five skill symlinks under `~/.claude/skills` in `nix/hm-module.nix`.
A recent change fixes multi-root workspace commit-message generation by replacing a singleton, cached-first-workspace behavior with active-repo resolution, so each open repository in a multi-root session can generate commit messages against its own source control root instead of the wrong project.
ContributionRemoved the singleton CommitService pattern that cached the first workspace root and added active repository resolution via `SourceControl.rootUri` as a workspace-root hint, enabling commit message generation to target the currently active repo in multi-root setups.
ImpactDevelopers using this extension in multi-root VS Code workspaces can generate commit messages for the intended repository instead of the wrong one, reducing workflow mistakes where automation and review tooling act on an incorrect project context. The fix is implemented by dropping first-root caching and passing the active SourceControl root as a hint for commit-generation calls, so operations stay aligned with the selected repo; follow whether root detection remains stable for unusual repo layouts (e.g., nested or symlinked folders) after future upgrades.
The PR changes Slack outbound message handling so markdown tables are rendered as native Slack Block Kit `table` blocks by default, with automatic fallback to the previous monospace section only when Slack table limits are exceeded or when a second table appears in the same message.
ContributionAdded a block-aware message contract (`OutboundPayload`) and updated `formatMessage`/`sendMessage` to carry optional Slack blocks, then implemented `markdownToSlackPayload()` so normal markdown tables go out as native Slack tables while the system falls back to monospace code-fence formatting when table size/cell/multi-table constraints are exceeded.
ImpactUsers and operators sending tables through agor to Slack now get clearer, properly aligned table rendering in common cases instead of crude code-block formatting, while oversized or repeated tables still remain readable through a controlled fallback path. Continue monitoring `blocks` payloads for Slack API schema errors and watch fallback-trigger behavior around wide/long/multi-table messages, because those edge cases are now the practical correctness boundary of the new rendering path.
This change makes `truncateToWidth` accept legacy string ellipsis arguments in the TypeScript wrapper (while keeping enum/null values on the existing native path), so calls like `truncateToWidth(text, width, "")` from older/custom TUI renderers no longer hit the strict native enum conversion that could crash rendering.
ContributionAdded compatibility handling in the `truncateToWidth` TypeScript wrapper so string ellipsis values are processed safely before native dispatch, preserving backward compatibility for legacy/custom call sites and preventing the specific N-API enum-conversion crash path.
ImpactLegacy terminal UI apps and integrators using older `truncateToWidth` call patterns can keep rendering instead of crashing when width truncation is invoked with an empty-string ellipsis, reducing user-facing rendering failures in interactive sessions. The fix works by short-circuiting legacy string ellipsis inputs into wrapper-side handling while continuing to route enum/null inputs to the native path; next watch point is whether similar legacy value-shape mismatches exist in nearby native-bound TUI APIs that still assume strict enum types.
The pull request makes the installer CLI actually execute the new server-beta runtime setup path and updates install-time behavior so runtime selection consistently controls setup actions, outputs, and status messaging.
ContributionIntroduced the `server-beta` setup orchestrator into the installer CLI (`setupServerBeta()` with rollback on failure) and corrected installer UX regressions, including `install --help` triggering no install body, complete IDE summary listing, runtime-aware success URL/port output, and runtime-appropriate post-install status messaging.
ImpactDevelopers and operators running `claude-mem install` can now avoid accidental actions from `--help` and better judge whether their IDE and runtime environment is correctly configured before using it, because install output now reflects the actual selected runtime. Technically, the CLI now delegates `--runtime server-beta` to the dedicated server-beta setup path and normalizes post-install details such as URL, port, and status text; monitor for compatibility with the prerequisite #2544 merge, and verify rollback behavior and runtime messaging in real deployments to catch any future mismatch between worker and server-beta flows.
The PR changes oh-my-pi’s GitHub Copilot auth flow so model calls carry `Copilot-Integration-Id: vscode-chat` and login stores a stable numeric GitHub user id in credentials, enabling existing dedup logic to match repeat logins instead of appending duplicates.
ContributionIntroduces two concrete auth reliability fixes: it scopes Copilot model requests to the correct integrator (`vscode-chat`) to prevent token-scope model denial, and it uses GitHub’s stable numeric user id from `/user` as `accountId` so repeated logins resolve to the existing credential row instead of creating new ones.
Impactoh-my-pi users relying on Copilot credentials will get more stable model access and cleaner auth state because calls are routed under the correct Copilot integrator and repeated logins no longer proliferate duplicate credential rows. Previously, `ghu_` tokens could hit an incorrect scope and intermittently return `model_not_available_for_integrator`, while missing `accountId`/email made dedup impossible; adding the integration header and persisted user id addresses both. Watch whether non-standard Copilot token sources still bypass the expected scope behavior, and monitor cases where `/user` lookup fails (best-effort path is silent, so duplicates can still appear if that fetch is unavailable).
The main change in this burst is the default flip of `NOTEBOOKLM_STRICT_DECODE` to `1`, so invalid or drifted `batchexecute` response shapes now raise `UnknownRPCMethodError` via `safe_index` instead of silently returning `None`, with `NOTEBOOKLM_STRICT_DECODE=0` retained only as an explicit one-release compatibility override.
ContributionIntroduced a stricter default decoding contract for RPC responses and added ADR/docs/tests to lock in behavior, so malformed `batchexecute` payloads are surfaced as explicit errors during response parsing rather than being treated as soft failures.
ImpactIntegrators and operators will now see hard failures when RPC response schemas drift, so bad API payloads stop silently corrupting downstream flow and can be detected and handled immediately instead of appearing as puzzling `None` values later. This is a behavior-breaking reliability fix for clients relying on RPC summaries and method lookups, and it is worth watching for downstream breakage in older integrations, the completeness of `UnknownRPCMethodError` handling paths, and whether fallback to `NOTEBOOKLM_STRICT_DECODE=0` is still needed beyond the intended transition window.
A code fix adjusts artifact type filtering in notebooklm-py so unknown and quiz/flashcard artifacts are handled more correctly, reducing misclassified entries in API artifact lists.
ContributionCorrected the artifact filtering logic to better classify edge-case artifact kinds, specifically unknown and quiz/flashcard artifacts, during API artifact selection/retrieval.
ImpactDevelopers and operators consuming NotebookLM artifact APIs will see cleaner artifact result sets for quiz/flashcard and unknown types, so downstream tooling can avoid extra cleanup steps and manual handling of wrongly included/excluded items. This change likely comes from a stricter artifact-type filter path, so teams should monitor whether any existing integrations that depended on the previous permissive filtering lose access to valid custom artifact types.
This change renames lifted internal `_core_*` collaborator modules to explicit session/transport/auth/cache/metrics ownership names, updates imports/docs/tests to match, and preserves `_core.py` as a private compatibility shim so external behavior is unchanged.
ContributionMigrated internal module naming and layout for lifted collaborators to explicit ownership namespaces (session, transport, RPC, cache, metrics), and aligned imports, docs, and tests with that structure without changing public APIs.
ImpactDevelopers and downstream integrators can keep using notebooklm-py with the same runtime behavior while the codebase becomes easier to navigate and maintain because internal ownership is now explicit; we should keep monitoring downstream/custom import paths for direct references to retired `_core_*` names or stale `test_core*` references, since those are the most likely compatibility break points despite the shim.
The PR relocates the concrete orchestration implementation from `ClientCore` in `_core.py` to `Session` in `notebooklm/_session.py`, and converts `_core.py` into a compatibility re-export shim for legacy private imports.
ContributionIntroduced a canonical internal implementation path (`_session.Session`) for session orchestration, updated package/docs/tests/fixtures/ADRs to reference it, and retained compatibility aliases and monkeypatch surfaces so existing private `_core` callers continue to work.
ImpactDevelopers and integrators relying on internal notebooklm behavior can keep legacy private flows working while the team starts using a single canonical session implementation path, which reduces accidental breakage when making internal changes. Public behavior is unchanged for `NotebookLMClient`, so immediate user-facing risk is low, but teams should continue watching for remaining private imports to `_core` and any monkeypatch-dependent paths that could diverge as future refactors move fully to the new layering.
This PR adds new CLI options to `install_skills.sh` (`--global`, `--agents`, `--cursor`) so skills can be installed to shared or tool-specific directories such as `~/.claude/skills`, `~/.agents/skills`, and `~/.cursor/skills`, with Genie-targeting support via `/Workspace/.assistant/skills` when combined with `--install-to-genie`.
ContributionIntroduces configurable installation destinations for ai-dev-kit skills, replacing local-only installs with reusable global and IDE/tool-specific paths, which removes manual copying and simplifies multi-tool setup.
ImpactDevelopers using multiple assistants or IDE integrations can deploy skills once and share them across tools and environments, so they avoid repetitive install steps and inconsistent skill availability between CLI workflows, Copilot-style tools, and Cursor sessions. The script now routes installs based on explicit flags to stable paths (`~/.claude/skills`, `~/.agents/skills`, `~/.cursor/skills`, and `/Workspace/.assistant/skills` with `--install-to-genie`), so teams should watch for directory permission issues, accidental install-path collisions, and whether existing local scripts still assume a single destination.
The PR introduces a Kiro-focused install flow in ai-dev-kit, adding installer detection and a `--tool kiro` option so skill installation writes artifacts to `.kiro/skills` and MCP settings to `.kiro/settings/mcp.json`, with docs updated to reflect Kiro in the general tool integration guidance.
ContributionAdded first-class Kiro support in the installer path by wiring Kiro detection and a dedicated `--tool kiro` branch in `install_skills.sh`, then directing generated skill assets and MCP configuration into Kiro’s expected locations so Kiro users can provision and register skills through the standard ai-dev-kit setup flow.
ImpactDevelopers and operators using Kiro IDE can now enable ai-dev-kit skills through the normal install scripts instead of manual file setup, which should reduce integration friction and misconfiguration during onboarding. The change standardizes where `.kiro/skills` and `.kiro/settings/mcp.json` are produced, and the README updates make the flow discoverable beyond Claude-only usage. Watch for edge-case installer failures across shell and platform differences and whether generated MCP config remains compatible with future Kiro/CLI schema changes.
The release’s main shift is speech-driven feedback in Agent Manager inline reviews: it adds support to record and send voice prompts in review comments and tightens the markdown-rendering path so capture is less likely to be interrupted during that flow.
ContributionIntroduces a concrete workflow change where reviewers can dictate inline comments instead of typing, with the send action for recorded voice prompts wired directly to the prompt submit path and stability work in the rendered Markdown review view.
ImpactCode reviewers can now dictate and submit inline review comments by voice in Agent Manager, which can make review sessions faster and less interruptive for teams that use conversational input. This is especially important where review throughput is constrained by typing speed, because it changes the review loop from manual text entry to speech-first interaction. Watch for practical regressions in voice transcription reliability and prompt-delivery failure rates during long or frequently updated diffs.
This change introduces explicit AIDLC v2 alpha visibility in repo docs and issue forms, giving users a clear way to report against v1 or v2 alpha instead of mixing versions.
ContributionAdded repo-facing guidance for v2 alpha (README banner) and a version selector to bug report, feature request, and documentation issue templates so issue metadata now records whether a report is for v1 or v2 alpha.
ImpactDevelopers and maintainers can now file and triage AIDLC issues against the right release line, which reduces confusion and misrouted bug reports as v2 alpha usage grows; watch whether reporters actually choose the correct version and whether any additional issue forms remain outside this dropdown.
Added MySQL IAM authentication to mirrord’s configuration path, with schema and lint updates, enabling IAM-based DB access configuration in this change line.
ContributionIntroduced IAM-based authentication support for MySQL in mirrord, including schema and linting changes to validate and gate valid IAM auth configurations.
ImpactDevelopers and operators using mirrord to work with MySQL can use IAM credentials instead of static secrets, which can reduce credential-management burden and lower the risk of leaked long-lived database passwords in local-to-cluster workflows. The change also appears to formalize IAM auth fields in config plus lint validation, so misconfigured IAM settings can be caught before runtime; teams should watch token expiry/refresh behavior, permission-scoping correctness, and any auth-mode compatibility issues with existing password-based setups.
This change removes the deprecated upstream `sdks/vscode` extension from the repo’s tracked upstream set and updates the upstream-merge automation to skip `sdks/vscode/**`, preventing the sync process from expecting files that are no longer present, while dropping stale annotation/changelog references tied to that removed SDK.
ContributionIntroduced a cleanup/removal of the upstream `sdks/vscode` package from the active code path and synchronized repo maintenance logic so CI/merge tooling excludes `sdks/vscode/**` from upstream merge processing. Also removed stale annotation and changelog references to avoid residual maintenance checks on a removed component.
ImpactDevelopers and integrators maintaining Kilo’s upstream sync will stop hitting unnecessary failures or review noise caused by references to a removed VS Code SDK package, so their sync, merge, and review steps stay focused on actually supported components. In practical terms, this should reduce broken checks and confusion during updates, while keeping changelog/annotation output aligned with shipped code. Watch for any remaining scripts or docs that still assume `sdks/vscode` exists, and verify that future package removals are added to the same skip policy to avoid a repeat of stale-file coupling.
Upgrades Copilot integration from one-off pattern-based starts to a session-aware flow by detecting existing Copilot sessions on disk, resuming them automatically, and wiring model/allow-all configuration into Copilot startup.
ContributionIntroduced a new Copilot session hook path that reads `~/.copilot/session-state/<session-id>/events.jsonl` for `session.start` records matching the working directory and starts Copilot with `--resume <session-id>` when prior conversation exists, while propagating session IDs through tmux and adding per-instance/TOML-driven `model` and `allow_all` startup options.
ImpactDevelopers and operators using Copilot inside agent-deck can continue ongoing AI coding sessions across restarts and pane boundaries without manual reinitialization, so long workflows keep context and reduce wasted prompt cycles; this is important to watch next because the new file-based discovery can still resume the wrong or stale session if session state files are incomplete, duplicated, or mismatched to the active project. The implementation also adds a config-based model/allow-all path (`~/.agent-deck.toml` and instance fields), so verify that non-standard install paths (`COPILOT_CONFIG_DIR`) and tmux environment propagation keep session IDs isolated per instance.
This PR updates the dependency on @chenglou/pretext from ^0.0.5 to ^0.0.7, making the library side-effect-free for better bundling and bringing line-break behavior changes (such as no-space mixed-script and punctuation/number wrapping) that are intended to match browser-style text layout more closely.
ContributionThe change introduces the v0.0.7 pretext runtime in this repository, which both enables tree-shaking through side-effect-free declarations and updates core layout behavior (`layoutNextLine` paths and line-break rules) to handle mixed Latin/CJK/numeric strings, punctuation chains, and soft-hyphen boundaries more like browsers.
ImpactUsers viewing rendered chat/markdown text in hyperframes should get more stable and predictable line wrapping for mixed-language and symbol-heavy content, with fewer odd punctuation or hyphenation artifacts in the UI; teams should validate typography regressions in custom-heavy pages before and after the merge. The upstream package now also reports itself as side-effect-free, which can reduce shipped JS by allowing unused entrypoints to be dropped, so keep an eye on bundle behavior for any modules that accidentally relied on import-time side effects. If custom scripts depend on the old wrapping quirks, verify they still produce expected results.
Moved JetBrains package guidance into `packages/kilo-jetbrains/AGENTS.md` and removed the separate UI skill doc, making this one file the canonical reference for IntelliJ agent guidance.
ContributionImplemented documentation consolidation by deleting the standalone UI skill guidance and migrating its required instructions into one authoritative JetBrains AGENTS guide, including threading and UI-constant conventions.
ImpactDevelopers extending or operating Kilo's JetBrains agents can now follow one canonical guide instead of reconciling multiple docs, which should reduce setup errors and inconsistent UI implementation choices during integration work. The new source-of-truth now covers IntelliJ source lookup, split-mode architecture, EDT/threading assumptions, and `UiStyle`-driven reusable UI constants; watch for broken links or onboarding scripts still pointing to the removed UI skill file and for teams still applying the obsolete guidance in parallel.
The PR adds persistent column reordering for `DataGrid` by introducing a `useColumnOrder` hook and an optional `storageKey` prop, so reordered columns are saved to `localStorage`, validated on restore, and reapplied after reloads while preserving current defaults when storage is unavailable.
ContributionAdded persistent column ordering support to `DataGrid` through a new `useColumnOrder` hook that stores and restores drag-and-drop column order in `localStorage` and safely handles invalid or stale saved orders by normalizing against current columns and defaulting when needed.
ImpactUsers working in InsForge tables will keep their custom column layout after refresh, which reduces repeated manual reconfiguration and makes repeated review/analysis sessions faster and less error-prone; teams should monitor whether order persistence degrades when browser storage is cleared, unavailable, or contains outdated/malformed entries because the grid may revert to a default layout. Technically, this is implemented with a configurable `storageKey`, a reorder persistence path in `onColumnsReorder`, and key validation during restore.
Studio’s right-side inspector now supports a multi-tab workflow with a dedicated CSS tab, letting designers keep Layers, Design, and CSS work in one area while the open/focused tabs are persisted in URL state. The change also adds guardrails for tab behavior (default Design tab, max two open tabs, single-tab full-height layout) and includes test coverage for panel-state/rendering behavior.
ContributionRefactors right-panel state into explicit structures (`rightPanelTabs`, `rightPanelFocusTab`), wires that state through layout/session/selection/url hooks, and applies feature-flag gating for inspector rendering so authored CSS editing can flow through the same right inspector path with controlled multi-tab behavior and URL persistence.
ImpactStudio editors can now switch among Layers, Design, and CSS inside one right inspector without losing their place, which should reduce workflow friction and speed up complex editing sessions. The implementation persists tab state in the URL and enforces simple constraints (maximum of two tabs and full-height single-tab mode), while routing authored CSS changes through file-history flow for preview refresh; continue watching for URL tab-state desync across sessions, stale rendering states when selection changes, and edge cases where CSS edits fail to refresh correctly under the feature flag.
Superset PR #4616 adds a dedicated `local` deployment profile with a `bun setup:local` entrypoint so a fresh worktree can boot a full local web/API/desktop stack using local Docker Postgres and Electric without requiring Neon/OAuth/Stripe/Resend/QStash/Upstash credentials. The local path also derives worktree-specific environment/state, while cloud and internal profiles keep strict env validation.
ContributionIntroduced a local-first contributor bootstrap mode that automatically prepares `.env`, initializes per-worktree local DB and desktop state, starts local infrastructure, applies migrations, and relaxes integration checks in local/CI for missing third-party keys while preserving strict validation in cloud/internal modes.
ImpactDevelopers can bring up a runnable local Superset stack from a fresh clone without waiting for external service keys, which reduces onboarding friction and avoids blocking issue reproduction on missing credentials. The change adds a contributor-focused path (`bun setup:local`, local profile, local env derivation, and worktree-specific state) that routes nonessential integrations like OAuth, Stripe, and Resend to non-fatal paths in local mode instead of hard-failing startup. Continue watching whether local-mode permissiveness hides real integration regressions, and verify that per-worktree names remain unique enough as the number of cloned worktrees grows.
The merged PR performs a repository-wide rename in AionUi, replacing `aioncli` references with `aioncore` for the CLI binary, bundled directories, and the prepare script, while also updating related CI labels, scripts, errors, comments, and GitHub repo naming references.
ContributionStandardized the project’s CLI/runtime naming surface by renaming all in-repo references and bootstrap/build scripts from `aioncli` to `aioncore`, aligning startup, packaging, and repo metadata with the new identity while keeping `@office-ai/aioncli-core` intentionally unchanged.
ImpactDevelopers and automation pipelines that launch, package, or test AionUi now match their scripts and toolchain to the new `aioncore` naming, reducing failures from stale entrypoint/path references and making release/deploy flows consistent with the repository rename. Continued monitoring is needed for external wrappers, docs, or third-party scripts that still call old `aioncli` paths, plus validation that these changes do not create hidden breakage in custom integrations that bypass the updated in-repo scripts.
Introduces a dedicated Pi adapter path in claude-mem’s CLI adapter layer so Pi hook events are routed through worker-side handling and normalized to a consistent `pi` platform source.
ContributionAdded and registered a Pi worker adapter plus `getPlatformAdapter()`/`normalizePlatformSource()` updates to normalize `pi-mono` to `pi`, enabling Pi session events from the new Pi hook integration to be ingested and stored in existing claude-mem workflows.
ImpactPi operators and integrators can now keep Pi event and observation flow inside the same claude-mem pipeline used by other platforms, so Pi-driven sessions become trackable and queryable without adding bespoke installer logic in this repository. The adapter accepts both Pi native and canonical input shapes, preserves existing hook output fields, and maps legacy `pi-mono` slugs to `pi`, which should reduce onboarding friction for teams testing the upcoming Pi extension package, but watch for schema drift between the future extension package and the worker contract because mismatched payload shapes could silently drop observations.
This release fixes a terminal lifecycle bug where close/reopen terminal actions could spawn duplicate terminal instances, which previously cluttered workspaces with extra shells.
ContributionA terminal management fix was added to prevent duplicate terminal creation during terminal close/open flows, reducing repeated process starts from a single user action.
ImpactDevelopers using Emdash will avoid unexpected extra terminal windows after closing or reopening sessions, so workflows stay cleaner and command execution is less likely to run in the wrong or redundant terminal. This change tightens terminal lifecycle handling in the shell panel; continue watching for regressions when terminals are created from lifecycle UI paths (for example, hover-triggered actions) and during high-frequency terminal operations in large workspace sessions.
The PR fixes a path configuration bug where the research toolkit hardcoded VAULT_PATH to one developer’s local Obsidian vault, causing other users’ notes and generated obsidian:// links in /youtube, /research, /research-deep, and /notebooklm to be written to a non-existent location. It switches resolution to OBSIDIAN_VAULT_PATH via the shared get_required helper and updates .env/setup flow so the value is written in setup.sh for standalone CLI runs.
ContributionChanged research note storage to use the repository-standard OBSIDIAN_VAULT_PATH with get_required validation, so vault writes now fail fast with the standard message instead of silently targeting a wrong personal path; added setup.sh env propagation into research .env for standalone CLI sessions.
ImpactUsers running the research toolkit on any machine besides the contributor’s now save notes to their configured Obsidian vault correctly, so their research notes and generated obsidian:// deep-links are much less likely to break or disappear. This is achieved by deprecating the hardcoded vault path in favor of OBSIDIAN_VAULT_PATH plus get_required validation; next, monitor onboarding workflows where this variable is missing or not loaded in CI/automation because this change intentionally changes silent misrouting into explicit configuration failure.
oraios/serena introduced CUE language support (`cue lsp`) as the main technical change in this 10-commit burst, enabling the project to work with CUE files through editor language-server integration.
ContributionAdded CUE language support by wiring in cue language-server protocol handling, so Serena can now understand and assist with CUE syntax in IDE flows instead of only supporting existing release/version workflows.
ImpactDevelopers maintaining CUE-based configurations can use Serena for language-aware editing support, which can reduce manual context switching and errors when moving across mixed-language codebases. The immediate follow-up to watch is whether `cue lsp` is reliably discovered in different IDE setups, and whether CUE files trigger the right language-server path without regressions in existing project workflows.
Serena now supports editing `.cue` projects through a dedicated CUE language server (`cue lsp`), with `Language.CUE` registration and platform-aware LSP setup so CUE symbols and cross-file references can be resolved inside the tool.
ContributionImplemented a new CUE LSP integration path in the language-server layer, including auto-fetch and SHA-256 verification of supported `cue` binaries, configurable binary/version overrides, and test coverage for CUE startup and cross-file symbol/reference behavior.
ImpactDevelopers using Serena on CUE repositories can now get built-in language-aware editing features for `.cue` files (symbol trees and cross-file references), which should make configuration validation and navigation easier during development instead of relying on external tooling or manual inspection. The change depends on an external `cue` binary, so teams should monitor first-run download reliability, pinned-version compatibility with new `cue` releases, and startup behavior of the `workspace/configuration` handshake in large or constrained environments.
Athas v0.7.0’s primary change is a core editor backend migration: the release replaces the legacy overlay editor surface with Monaco and routes editor command/settings behavior through that engine, signaling a move to a single editing implementation.
ContributionSwitched the primary editing subsystem from a custom overlay-based implementation to a Monaco-backed engine, including command routing and settings integration in Monaco, so editing workflows now run on a unified engine path instead of mixed legacy/custom paths.
ImpactDevelopers using Athas should get a more consistent editing experience from v0.7.0 because the editor now runs through a single Monaco backend, which is likely to reduce UI/interaction inconsistencies and make behavior for common actions (commands, settings, cursor/search flows) more predictable. Watch for regressions in less common editor workflows, especially custom extensions, Vim-mode behavior, and large-file performance while the old overlay-based assumptions are fully retired.
This PR adds a new CLI command that automates fetching the dependencies required by Serena language servers and provides clearer feedback when dependency downloads fail.
ContributionAdded a new command-line workflow that performs dependency bootstrap for language servers in one step, replacing manual dependency setup and making download errors immediately visible during setup.
ImpactDevelopers and operators can set up Serena language servers through a single command instead of manual install steps, which reduces environment drift and setup mistakes and makes it easier to catch broken installs before running the IDE integration. The new CLI path should be watched for practical reliability gaps—especially download failure handling, transient network outages, permission/path issues, and whether dependency version mismatches are reported clearly as projects and CI automate setup.
This PR adds new Serena tools (`completion`, `hover`, `get_diagnostics`, `inlay_hints`) so AI agents can inspect symbol members, documentation, and diagnostics through the language server interface across Java, TypeScript, Python, and Rust; manual testing confirms completion/hover/diagnostics behavior for those languages, while inlay hints return empty results in Java and TypeScript.
ContributionImplemented new LSP-backed interaction endpoints (`completion`, `hover`, `get_diagnostics`, `inlay_hints`) to let AI assistants query symbol information and compile-time warnings/errors without requiring full local source inspection or repeated build cycles.
ImpactDevelopers and AI coding assistants using Serena can get immediate symbol docs, completion suggestions, and diagnostic feedback while working, which can reduce API mistakes and shorten troubleshooting before running larger build/test steps. This depends on each language server’s capability support, so the remaining risk is uneven tool behavior—`inlay_hints` is still empty for Java/TypeScript in current tests—and operators should watch whether hint and diagnostics responses stay consistent as more languages or setups are used.
This change adds a dedicated `bigmodel` provider so jcode can route mainland China users to the Zhipu BigModel OpenAI-compatible path by default (`glm-5.1`), while keeping the existing `zai` provider behavior for overseas endpoints.
ContributionIntroduced a separate BigModel provider path in core selection and auth/login flows and added default-provider guardrails so jcode does not silently fail over to another provider when BigModel credentials are missing.
ImpactMainland China users configuring jcode for BigModel can now get predictable request routing to `glm-5.1`, which reduces silent cross-provider redirection and the risk of wrong-provider usage, billing surprises, and confusing auth errors. The PR also preserves existing `zai` routing for overseas use and makes missing BigModel credentials fail explicitly rather than being auto-routed. Operators should continue to watch provider alias/env variable resolution and static model fallback behavior as provider catalogs evolve.
Release v0.13.5 makes web and remote workspace users able to upload and download files and folders directly from the file tree through streamed transfers, with no file-size cap and a unified progress dialog that supports cancellation.
ContributionIntroduced a direct in-UI workspace transfer path that replaces manual/indirect file sync steps with tree-based, streaming upload/download for both files and folders, while adding safer validation for upload payloads and zip downloads.
ImpactWeb and remote workspace users can transfer large files and folders directly from the file tree without manual export/import steps, which cuts operational friction and makes collaboration on bigger artifacts practical and faster. The update also hardens the same transfer path with streaming behavior and centralized progress/cancel handling plus stricter upload and zip validation, so teams should monitor cancellation correctness, large-transfer stability, and whether the stricter checks produce false positives for legitimate archives.
This change fixes a persistence recovery failure by making Desktop only reuse local Workers it started for the same app version, while marking legacy or owner-missing connection records as stale and repairing them before replacement.
ContributionAdds explicit runtime ownership/version checks to local Worker selection: Desktop writes normalized `appVersion` and `startedBy` metadata, passes app version into spawned Workers via `--app-version`, and enforces a version match for reusing Desktop-started Workers while still allowing CLI-started Workers via protocol compatibility.
ImpactDesktop users who upgrade the app are less likely to open with stale or missing workspace state, because the launcher now avoids attaching to an old Desktop-started local Worker from a prior version and instead triggers proper recovery against the current runtime. Technically, the fix writes owner/version metadata to the control-surface path and treats legacy/no-owner files as stale for Desktop launches, then repairs connection and lock state before replacement; continue watching for startup delays or unnecessary respawns caused by protocol-check and lock-file race conditions during upgrade flows.
The PR updates the editor input flow so delete- and cut-related input events always clear React selection state, preventing the selection from staying visually selected after text removal.
ContributionIn `src/features/editor/hooks/use-editor-textarea-input.ts`, the input handler now treats deletion-related `InputEvent` types as unconditional selection-reset paths, so stale DOM-based selection bounds are not restored into React state after deletion; this directly addresses the visual persistence of a selected range after Backspace/Delete/Cut.
ImpactUsers deleting text in athas editor flows will see the selection collapse correctly after removal, so typing continues at the expected cursor point instead of acting on a visually stale selection state, and teams should keep monitoring cross-browser delete/cut edge cases for any remaining selection desync. In practice, the change avoids a misleading cursor/selection state that could cause accidental extra edits, especially where browser engines (notably WebKit) report inconsistent selection bounds; continued verification is needed on less-covered input paths and future DOM engine behavior.
AionUi now changes agent startup behavior to initialize only when a user starts typing, instead of doing warmup proactively, reducing background overhead during idle use in the v2.0.3-dev-973e784 prerelease.
ContributionIntroduces on-demand agent initialization by moving agent warmup from eager startup behavior to a lazy, first-typing trigger.
ImpactUsers and developer operators should see a snappier initial interaction because the app no longer does agent warmup work before any real input arrives, so sessions that are opened but not actively used avoid extra startup overhead. This is implemented by deferring agent startup until the first typing event; teams should watch for first-keystroke latency regressions and any initialization failures that only surface when warmup is delayed under real user interaction.
The release’s key change is new task completion functionality, with UI updates that expose completed task state to users.
ContributionIntroduced a completion path for tasks and updated the task interface so finished work is explicitly represented, replacing the previous implicit/ambiguous state model.
ImpactUsers can now see clearly when a task is finished, reducing manual checking and operator confusion during active work sessions. This likely lowers mis-operations caused by treating in-progress tasks as complete or vice versa; operators should still watch for stale completion indicators after restarts or interrupted updates, and whether completion status is reliably persisted across sessions.
Emdash v1.1.16’s central change is a reliability-focused update to remote/SSH project workflows: it adds SSH connection settings and related remote-handling fixes so remote development no longer behaves as inconsistently.
ContributionAdds a focused remote-workspace stability track by introducing SSH connection settings and fixing remote project behavior, including hardened remote project handling, remote file change detection, and remote agent selection in conversation creation, which directly targets consistency when working with non-local repositories.
ImpactDevelopers using Emdash against remote or SSH-backed repos should see fewer session interruptions and fewer cases where edits appear out of sync, which reduces manual refresh/reconnect overhead during reviews and coding; they should continue watching whether long-running remote sessions remain stable under heavy edit activity. The release ships concrete control and sync improvements in remote project handling (SSH settings UI and remote-change detection path fixes), so the main follow-up risk is a recurrence of remote session dropouts or missed remote updates on large or long-lived worktrees.
v0.4.1 addresses the release’s dominant change: making Google session cookie rotation reliable for long-lived and parallel NotebookLM automation. `fetch_tokens` now performs an explicit `RotateCookies` flow and the keepalive path gains dedupe controls (async locks plus a cross-process lock file) so stale-cookie failures do not recur under fan-out execution.
ContributionImplemented concurrency-safe auth keepalive behavior by adding background/refresh-time cookie rotation that writes fresh cookies back to the caller’s storage path and by preventing rotation stampedes across asyncio tasks and parallel processes. The same flow also normalizes and serializes cookie saves so in-flight requests do not lose freshness updates.
ImpactOperators of unattended NotebookLM workloads (agents, cron jobs, MCP worker pools) can expect fewer sudden auth-related job failures, because session cookies are now refreshed proactively and duplicate refresh attempts are suppressed when many callers hit auth simultaneously. After the change, token refresh uses `RotateCookies` on Google’s identity endpoint with a 60-second freshness floor, then persists rotated cookies via the storage path; the keepalive path also uses in-loop and filesystem lock coordination to avoid overwrite races. Keep watching for environments where `accounts.google.com` is intermittently blocked and for lock-file semantics on the target filesystem, because either condition can still make automation fall back to retry-heavy auth behavior.
This beta release tightens cc-connect Bridge security by enforcing that a token must be configured before Bridge can run, preventing Bridge mode from operating anonymously.
ContributionAdds a security gate in Bridge mode so requests are rejected unless a token is present, directly addressing unauthenticated Bridge usage introduced or left possible by default.
ImpactOperators and teams using Bridge now must provide valid credentials before the integration will work, which reduces unauthorized message relays and accidental exposure from untrusted peers while making misconfigured deployments fail fast. The technical change is a token-required check on Bridge startup/enablement paths; it should be monitored in beta environments for auth-related regression errors, especially in older automation scripts that may rely on token-less Bridge usage, because those integrations could break until updated.
v0.1.11 updates critical and high-severity dependencies in databricks-solutions/ai-dev-kit to patched versions, with the primary change aimed at reducing dependency-driven security exposure.
ContributionApplied a security-focused dependency upgrade that replaces vulnerable package versions with patched releases, changing the installed dependency set to close known security gaps.
ImpactDevelopers and operators upgrading to v0.1.11 should face fewer security incidents from known vulnerable libraries during installation and runtime, reducing the chance that existing toolchain usage is disrupted by known package flaws. The practical risk to watch next is functional or compatibility regressions from transitive dependency changes, so upgrade rollout should include installer and CI smoke tests plus checks on workflow integrations before wide deployment.