Track important changes in AI Debugging and Error Localization, including capabilities, product updates, adoption signals, risks, and evidence worth continued monitoring.
A single pull request addresses the root cause of mass session failures on shared-server by replacing fragile single-writer fallback behavior with safer fanout over active connections, preventing protocol events from being sent to the wrong client stream when multiple TUIs are attached; it also adds guarded handling for malformed JSON frames so one bad frame does not instantly abort all sessions.
What ChangedA single pull request addresses the root cause of mass session failures on shared-server by replacing fragile single-writer fallback behavior with safer fanout over active connections, preventing protocol events from being sent to the wrong client stream when multiple TUIs are attached; it also adds guarded handling for malformed JSON frames so one bad frame does not instantly abort all sessions.
Why It MattersOperators running multiple attached clients on the shared-server can avoid all connected TUIs dropping together from one malformed event, so collaborative sessions remain usable during long debugging or workflow windows instead of forcing broad reconnects after sudden disconnect storms. The server now avoids rewiring to stale/incorrect writers during concurrent session activity and handles isolated frame corruption as recoverable, so the immediate practical benefit is fewer full-session outages; watch for any remaining code paths that still assume one global fallback sender and monitor repeated malformed-frame sequences for an upstream formatting regression.
Final score 82Confidence 961 evidence itemshared-servermulti-session protocolmember.event_txmember.event_txsfanout_session_eventRemoteConnection::next_event
A wrong function name in the skills manager import caused an ImportError that blocked all skill lifecycle operations; correcting `get_default_skill_directories` to `get_default_skill_dirs` restores `create_skill`, `edit_skill`, `delete_skill`, `patch_skill`, and `write_skill_file` so the feature works again.
What ChangedA wrong function name in the skills manager import caused an ImportError that blocked all skill lifecycle operations; correcting `get_default_skill_directories` to `get_default_skill_dirs` restores `create_skill`, `edit_skill`, `delete_skill`, `patch_skill`, and `write_skill_file` so the feature works again.
Why It MattersDevelopers and operators using PraisonAI skills can now execute add/edit/delete/patch/write skill workflows without import-time crashes, so automation and manual maintenance of agents can proceed instead of failing unexpectedly. The patch swaps the bad import name for the correct one (`get_default_skill_dirs`), and teams should keep an eye on future renames or refactors in skill modules because another import mismatch could reintroduce the same class of outage.
Final score 82Confidence 991 evidence itemPraisonAISkillManagermanager.pydiscovery.pyget_default_skill_dirsget_default_skill_directories
Fixes a correctness bug in google/adk-go where `RunAgentRequest.stateDelta` was accepted by `/api/run` but not applied, causing resumed runs to ignore caller-provided state updates.
What ChangedFixes a correctness bug in google/adk-go where `RunAgentRequest.stateDelta` was accepted by `/api/run` but not applied, causing resumed runs to ignore caller-provided state updates.
Why It MattersClients and operators using `/api/run` or `/api/run/sse` for resume workflows will now get expected session context updates before the agent starts, so reruns no longer silently proceed from stale state and recoverability improves for long-running conversations. The fix now records `stateDelta` as a session event through `sessionService.AppendEvent` before execution, and teams should watch for edge cases in event ordering and malformed/rapidly changing `stateDelta` payloads that could still affect merge behavior at high scale.
Final score 82Confidence 981 evidence itemgoogle/adk-goadkrestRunAgentRequeststateDeltaRunHandlerRunSSEHandlersessionService.AppendEventEventActions.state_deltaapplyStateDeltaIfPresent
A pull request updates Claude project key generation to treat `.` and `@` as replaceable characters when deriving project IDs, aligning generated keys with Claude Code’s on-disk directory naming and preventing session lookup mismatches that made `/list` return empty for certain workspaces.
What ChangedA pull request updates Claude project key generation to treat `.` and `@` as replaceable characters when deriving project IDs, aligning generated keys with Claude Code’s on-disk directory naming and preventing session lookup mismatches that made `/list` return empty for certain workspaces.
Why It MattersDevelopers using Claude in directories like `.nvm` or scoped package paths such as `@anthropic-ai/claude-code` can now get accurate `/list` session results instead of empty output, which prevents silent failures when they need to resume the right project context. The update keeps session discovery consistent with Claude Code’s naming scheme, and operators should still watch for any other special characters in workspace paths that could remain unmatched and reintroduce silent key drift.
Final score 82Confidence 971 evidence itemencodeClaudeProjectKeyfindProjectDirClaude Code project keys/.claude/projects/
The PR changed `firstLine()` in `internal/watcher/webhook.go` to ensure truncated subject text always ends on a valid UTF-8 boundary (max 200 bytes), preventing invalid byte sequences from being written to `watcher_events.subject`.
What ChangedThe PR changed `firstLine()` in `internal/watcher/webhook.go` to ensure truncated subject text always ends on a valid UTF-8 boundary (max 200 bytes), preventing invalid byte sequences from being written to `watcher_events.subject`.
Why It MattersWebhook consumers and event operators avoid stalled forwarding loops caused by poisoned DB rows, so integrations like the Python bridge can continue stateful polling without repeatedly failing on the same row every 2 seconds. The change enforces validity-correct subject truncation by removing up to three trailing bytes after a 200-byte cap, which blocks downstream `sqlite3` UTF-8 decoding crashes; continued monitoring should verify no other event fields/callers can introduce malformed UTF-8 and trigger similar reprocessing backlog patterns.
Final score 82Confidence 991 evidence itemfirstLine()UTF-8 boundarywatcher_events.subjectinternal/watcher/webhook.gosqlite3
Agor now auto-copies each set `GIT_AUTHOR_*` environment variable to the matching `GIT_COMMITTER_*` only when that committer variable is not already provided, preventing commits from inheriting the executor host’s git identity and avoiding author/committer mismatches in PR metadata.
What ChangedAgor now auto-copies each set `GIT_AUTHOR_*` environment variable to the matching `GIT_COMMITTER_*` only when that committer variable is not already provided, preventing commits from inheriting the executor host’s git identity and avoiding author/committer mismatches in PR metadata.
Why It MattersOperators and reviewers using Agor will see commit and PR identity remain consistent when they configure only author metadata, so accountability in commit attribution is preserved and audit/review trails are less confusing. The change is implemented by setting `GIT_COMMITTER_*` from `GIT_AUTHOR_*` when absent, replacing host `~/.gitconfig` fallback behavior; watch for environments that intentionally depended on that fallback and for sessions with only partially provided author fields, since those should still be validated for correct identity outcomes.
Final score 82Confidence 981 evidence itemGIT_AUTHOR_NAMEGIT_AUTHOR_EMAILGIT_COMMITTER_NAMEGIT_COMMITTER_EMAILcreateUserProcessEnvironmentenv-resolver.test.tsAgor~/.gitconfig
`img_2_b64()` now explicitly decodes the Base64 result to a UTF-8-compatible string via `.decode("ascii")` instead of relying on `typing.cast`, preventing a bytes return type at runtime.
What Changed`img_2_b64()` now explicitly decodes the Base64 result to a UTF-8-compatible string via `.decode("ascii")` instead of relying on `typing.cast`, preventing a bytes return type at runtime.
Why It MattersDevelopers using LlamaIndex image conversion helpers can avoid runtime crashes when their `img_2_b64` output is inserted into `data:image/...` strings or serialized to JSON, which reduces unexpected failures in image pipelines and integrations. The fix replaces a static-type-only cast with a real decode step, closing a mismatch that caused `TypeError: Object of type bytes is not JSON serializable`; operators should monitor for callers that previously expected bytes and ensure regression tests cover JSON/data-uri paths.
Final score 81Confidence 991 evidence itemimg_2_b64base64.b64encodetyping.castbytesJSONdata URIstr return type
Updated `get_volume_file_metadata` to handle RFC 7231 HTTP-date strings from `files.get_metadata()` by parsing them to ISO 8601 before returning `last_modified`, with fallback to the raw value when parsing fails, instead of calling `.isoformat()` on a string.
What ChangedUpdated `get_volume_file_metadata` to handle RFC 7231 HTTP-date strings from `files.get_metadata()` by parsing them to ISO 8601 before returning `last_modified`, with fallback to the raw value when parsing fails, instead of calling `.isoformat()` on a string.
Why It MattersOperators and developers consuming Databricks volume metadata now avoid unexpected job interruptions when metadata fetches hit SDK string timestamps, so file-syncing, indexing, and automation pipelines are less likely to stop on `AttributeError` during normal runs; the PR also adds defensive handling of unparsable values, and should be watched for future SDK changes in `last_modified` typing or date format that could reintroduce parsing regressions.
Final score 81Confidence 971 evidence itemdatabricks_sdkfiles.get_metadataget_volume_file_metadatavolume_files.pylast_modifiedemail.utils.parsedate_to_datetime
The PR fixes a bug in mirrord where IPv4-only Kubernetes pods with only `::1` as an IPv6 address skipped IPv6 availability detection, so localhost connections using IPv6 loopback were not captured by mirrord steal/mirror and bypassed local redirection.
What ChangedThe PR fixes a bug in mirrord where IPv4-only Kubernetes pods with only `::1` as an IPv6 address skipped IPv6 availability detection, so localhost connections using IPv6 loopback were not captured by mirrord steal/mirror and bypassed local redirection.
Why It MattersDevelopers and operators using mirrord with Go-sidecars or localhost-based tooling in IPv4-only clusters will stop losing request capture, because `localhost`-resolved IPv6 traffic (`[::1]:port`) will be mirrored to the local machine instead of bypassing diagnostics and observability flows. This is done by enabling IPv6 redirection setup when loopback is present, so the previous silent miss path is removed; teams should verify no regressions in mixed IPv4/IPv6 clusters and watch for unintended effects with existing IPv6 firewall rule sets.
Final score 81Confidence 961 evidence itemmirrordip6tablesIP_VERSION_AVAILABILITYIPv6 loopback (::1)mirrord steal modeKubernetes pod
The PR changes `permissionService`’s `skip` flag from an unsynchronized `bool` to `sync/atomic.Bool`, and routes all accesses through `Load`/`Store`, removing a concurrent read/write race between `Request`/`SkipRequests` and `SetSkipRequests`.
What ChangedThe PR changes `permissionService`’s `skip` flag from an unsynchronized `bool` to `sync/atomic.Bool`, and routes all accesses through `Load`/`Store`, removing a concurrent read/write race between `Request`/`SkipRequests` and `SetSkipRequests`.
Why It MattersOperators and developers running concurrent permission checks will get more stable behavior and fewer misleading race failures during testing because the permission skip switch no longer races across goroutines, which reduces nondeterministic skip-path behavior and makes permission flow debugging more reliable. The patch is technically constrained to the `skip` field, so teams should still monitor CI race-detector coverage and inspect neighboring shared state (including other permission/service paths) for similar unsynchronized access patterns.
Final score 81Confidence 961 evidence itempermissionServiceskip flagsync/atomic.BoolLoad/Storego test -raceTestPermissionService_SkipRace
The report identifies a single primary defect: cc-connect’s agent stdout read loops for codexSession and claudeSession can terminate a live session when output contains a line over ~64KB, matching the Go `bufio.Scanner` token-length failure mode. Repeated logs show both sessions returning `bufio.Scanner: token too long` and dropping the session after long JSON/JSONL lines.
What ChangedThe report identifies a single primary defect: cc-connect’s agent stdout read loops for codexSession and claudeSession can terminate a live session when output contains a line over ~64KB, matching the Go `bufio.Scanner` token-length failure mode. Repeated logs show both sessions returning `bufio.Scanner: token too long` and dropping the session after long JSON/JSONL lines.
Why It MattersOperators running cc-connect with codexSession or claudeSession can lose in-progress agent sessions when tools emit large one-line outputs, which can break prompts, pipelines, or long autonomous tasks that rely on uninterrupted stdout streaming. The underlying mechanism is the read loop’s use of `bufio.Scanner` with its default token cap, so watch for whether implementations switch to bounded, configurable handling that degrades safely (warning/truncation/fallback) without dropping the whole session, while also checking for any memory-growth risks from raising limits too aggressively.
Final score 81Confidence 941 evidence itemcc-connectbufio.ScannercodexSessionclaudeSessionagent stdoutGo
This PR adds a Windows-only `shell` flag to all `spawnSync` calls that invoke `npx` in `ruflo-cost-tracker`, preventing Node 21+ on Windows from failing with `ENOENT` and letting cost-tracking commands execute successfully.
What ChangedThis PR adds a Windows-only `shell` flag to all `spawnSync` calls that invoke `npx` in `ruflo-cost-tracker`, preventing Node 21+ on Windows from failing with `ENOENT` and letting cost-tracking commands execute successfully.
Why It MattersWindows users of `ruflo-cost-tracker` will now get reliable `cost track/summary/report` results instead of silent failures that looked like valid-but-empty cost data (`Persisted: FAILED` and `$0.0000`), which makes budget and optimization checks usable again in CI and operator workflows. The fix works by accounting for Node 21+ `.cmd/.bat` launch restrictions by turning on shell mode only on win32 for `npx`, with no behavioral change for non-Windows environments. Continue watching for two follow-ups: whether future Node versions alter Windows shell-launch semantics, and whether issue #2073 in `@claude-flow/cli` (`memory retrieve/export` returning null entries) is fixed, because read-path reports can still be incomplete even when spawn succeeds.
Final score 81Confidence 981 evidence itemchild_process.spawnSyncnpxWindowsNode.js 21+ruflo-cost-trackercost-tracking namespaceshell option
AionUi PR #2936 changes conversation navigation so that a deleted conversation ID returning 404 is handled in the fetcher instead of bubbling as an unhandled rejection, shows a single `conversation.notFound` warning toast, and redirects users to the home page using history replace so the stale route is not re-entered.
What ChangedAionUi PR #2936 changes conversation navigation so that a deleted conversation ID returning 404 is handled in the fetcher instead of bubbling as an unhandled rejection, shows a single `conversation.notFound` warning toast, and redirects users to the home page using history replace so the stale route is not re-entered.
Why It MattersDesktop users who delete a conversation and then navigate back no longer get stuck on a dead conversation page with repeated 404 failures; they now land on the welcome screen with a clear notice, which directly improves recoverability of everyday navigation flows and reduces crash-like support incidents. The fix works by catching the conversation fetch failure in `ConversationIndex`, preventing SWR from re-throwing it as an unhandled promise rejection, and using `replace: true` navigation plus `NavigationHistoryContext` cursor rewriting to keep the invalid route out of history; next, monitor whether other 404 conversation paths still leak to Sentry (especially ELECTRON-19G) and whether any legitimate back-navigation behavior regresses after the replace-based redirect.
Final score 81Confidence 951 evidence itemConversationIndexNavigationHistoryContextuseNavigationTypenavigate('/', { replace: true })Backend GET /api/conversations/<id> 404SWR fetcherconversation.notFound i18n key
The pull request changes the OpenAI stream error path by adding a defensive `response.text()` wrapper with a 5-second hard timeout and by making retry logic aware of hard-quota signals, including large `Retry-After` values. This prevents the coding agent from getting stuck on non-200 responses and stops auto-retry loops when the provider signals a hard usage limit.
What ChangedThe pull request changes the OpenAI stream error path by adding a defensive `response.text()` wrapper with a 5-second hard timeout and by making retry logic aware of hard-quota signals, including large `Retry-After` values. This prevents the coding agent from getting stuck on non-200 responses and stops auto-retry loops when the provider signals a hard usage limit.
Why It MattersOperators and users of the coding agent will see rate-limit failures fail fast instead of freezing in a perpetual "Working" state, so tasks no longer consume resources in endless retries when a provider has reached hard usage limits. The fix adds explicit extraction of `Retry-After` into error details and enforces a 5-second timeout on error-body reads, which reduces UI lockups and avoids retry storms on opaque upstream connection failures; teams should watch for regressions if providers rely on slower-error response patterns or if retry-window thresholds are too conservative for future billing or provider semantics.
Final score 81Confidence 971 evidence itemresponse.text()fetch interceptoropenai-nodeRetry-After_isRetryableError429 Too Many Requestshard quota limit
A single correctness-focused change adds empty-response checks before indexing `response.choices[0]` in 16 callsites across multiple `llama_index` LLM integrations, replacing unsafe direct access that could crash with `IndexError`/`AttributeError` when providers return no choices (issue #21337).
What ChangedA single correctness-focused change adds empty-response checks before indexing `response.choices[0]` in 16 callsites across multiple `llama_index` LLM integrations, replacing unsafe direct access that could crash with `IndexError`/`AttributeError` when providers return no choices (issue #21337).
Why It MattersApplications and teams using these `llama_index` providers will fail more predictably when an upstream model returns an empty completion, which reduces production incidents from ambiguous crashes and makes error handling/retries easier to automate. The patch changes 16 direct `choices[0]` dereferences to explicit checks and converts failures into a clear `ValueError`, but operators should watch for two adapters (Azure Inference and MistralAI) that still show incomplete pact proof status and ensure downstream code handles the new error type consistently.
Final score 81Confidence 971 evidence itemllama_indexLLM adaptersresponse.choicesempty responseValueError
This change replaces hashline’s stale-anchor repair flow, which previously used fuzzy 3-way merge, with a deterministic two-tier recovery path: direct apply when anchors still match, then structured line-shift correction, and finally corrected-anchor retry feedback using explicit remapped hash anchors. The result is a safer edit workflow that avoids silently writing wrong content when files change after being read.
What ChangedThis change replaces hashline’s stale-anchor repair flow, which previously used fuzzy 3-way merge, with a deterministic two-tier recovery path: direct apply when anchors still match, then structured line-shift correction, and finally corrected-anchor retry feedback using explicit remapped hash anchors. The result is a safer edit workflow that avoids silently writing wrong content when files change after being read.
Why It MattersDevelopers and operators relying on automated edits now avoid silent wrong-content merges when a file changes between read and write, so patch automation is safer and failures become recoverable instead of producing hidden corruption; technically, fuzzy matching is removed, pre-shift remapping is conservative and must be exact, and fallback now requires explicit corrected retry while full-file snapshots are refreshed after successful edits, so watch for fallback frequency and patch-mode escalations in rapidly changing files.
Final score 80Confidence 941 evidence itemhashline recoverycomputeLineShiftMapHashlineMismatchErrorbuildCorrectedEditFileReadCache
A new `praisonai doctor packaging` diagnostic command is introduced to catch Windows-specific installation and entry-point problems (including `python -m praisonai` vs `praisonai` execution mismatches) before users hit runtime daemon failures.
What ChangedA new `praisonai doctor packaging` diagnostic command is introduced to catch Windows-specific installation and entry-point problems (including `python -m praisonai` vs `praisonai` execution mismatches) before users hit runtime daemon failures.
Why It MattersWindows users and operators can now run a dedicated packaging health check before execution, so broken daemon starts caused by mismatched install or invocation paths are detected earlier and onboarding failures become less common. Technically, the change adds a new `praisonai doctor packaging` command and expands Windows entry-point validation with explicit checks (`praisonai --version`, `python -m praisonai --version`, `__main__.py`, command-path resolution, venv/PATH/encoding/context analysis), and follow-up should verify whether these checks produce false positives on customized environments or overly strict gating in CI for nonstandard setups.
Final score 80Confidence 931 evidence itemPraisonAIpraisonai doctor packagingWindows daemonpython -m praisonaipraisonai console scripttest-windows.yml
The PR adds explicit validation for duplicate entries in `incoming.port_mapping` and `listen_ports` so config generation now fails with a clear duplicate-port error instead of silently keeping only one mapping when duplicates exist.
What ChangedThe PR adds explicit validation for duplicate entries in `incoming.port_mapping` and `listen_ports` so config generation now fails with a clear duplicate-port error instead of silently keeping only one mapping when duplicates exist.
Why It MattersDevelopers and operators using mirrord network forwarding can catch bad port rules immediately, avoiding silent routing misconfigurations where one duplicate mapping vanishes and traffic is sent to the wrong local/remote port during debug sessions; this is especially important in environments where a single dropped rule can block access to a service. The change now rejects duplicate entries during config generation with explicit messages, so teams should watch for CI pipelines or templating tools that currently emit duplicate ports and may start failing builds until inputs are cleaned.
Final score 80Confidence 991 evidence itemmirrordmirrord-configport_mappinglisten_portsBiMapduplicate port validation
Refactor the InsForge backend startup flow so importing `backend/src/server.ts` no longer starts the service; app creation is moved to `backend/src/app.ts` and `initializeServer()` in `server.ts` only runs when the module is the process entrypoint, with a regression test added for import-safe behavior.
What ChangedRefactor the InsForge backend startup flow so importing `backend/src/server.ts` no longer starts the service; app creation is moved to `backend/src/app.ts` and `initializeServer()` in `server.ts` only runs when the module is the process entrypoint, with a regression test added for import-safe behavior.
Why It MattersDevelopers and automated test/jobs can import backend server code without unintentionally launching the HTTP process, so local tests and tooling stop blocking on already-bound ports or lingering processes during import. Technically, the startup path is now isolated to direct execution of `server.ts` via `isEntrypoint()`, while `createApp` remains exported for compatibility from the entry module; operators should continue watching whether all valid launch entrypoints still call the startup path correctly and whether any remaining module imports still perform other hidden side effects during load.
Final score 80Confidence 961 evidence itembackend/src/app.tsbackend/src/server.tscreateAppinitializeServerisEntrypointSIGINTSIGTERMserver startup side effects
The PR fixes packaging by running `npm install --production` during `scripts/build-hooks.js` and adding `plugin/node_modules` to the package `files`, so runtime modules such as `zod`, `shell-quote`, and `tree-sitter-*` are shipped with the marketplace bundle instead of being omitted at publish time.
What ChangedThe PR fixes packaging by running `npm install --production` during `scripts/build-hooks.js` and adding `plugin/node_modules` to the package `files`, so runtime modules such as `zod`, `shell-quote`, and `tree-sitter-*` are shipped with the marketplace bundle instead of being omitted at publish time.
Why It MattersUsers and operators on macOS/Windows are less likely to lose prompt sessions silently after upgrades, because the plugin package will now include the runtime modules needed for the worker to start and summarize sessions correctly. Technically, the build now performs a production install in `plugin/` and marks `plugin/node_modules` as distributable, replacing prior bundles that omitted those dependencies; continue watching for build-time drift in dependency sets, potential package-size impact, and whether install/signals are fully visible in mobile clients where hook errors were previously hidden.
Final score 80Confidence 961 evidence itemclaude-memscripts/build-hooks.jsplugin/package.jsonplugin/node_modulesnpm install --productionpackage.json files array
In this 7-day commit burst, the primary change is a stabilization pass on the new MSBuild authoring skills suite so it activates reliably in Copilot plugin mode and evaluates correctly. The updates rewrite SKILL.md descriptions and eval prompts, tighten routing language, and adjust timeout/fixture behavior to fix skipped or misrouted skill behavior and reduce noisy, timeout-driven scoring failures.
ContributionRestored reliable activation of four MSBuild specialization skills by fixing their metadata and prompt design: added explicit MSBuild/.NET-only activation cues, aligned USE/DO NOT USE routing language, shortened over-limit descriptions, and tuned prompts/fixtures/timeouts to reduce overfitting and timeout fallbacks.
ImpactDevelopers using dotnet/skills for Copilot-assisted code reviews are more likely to receive usable MSBuild-specific diagnostics and fix guidance in one attempt instead of generic or missing feedback, because the right skill is now consistently selected and less likely to be dropped by prompt routing. The follow-up watch is on routing stability and timeout behavior in multi-file scenarios; if either regresses, review accuracy and scenario pass rates could slip back toward false negatives despite the expanded skill set.
A single pull request addresses the root cause of mass session failures on shared-server by replacing fragile single-writer fallback behavior with safer fanout over active connections, preventing protocol events from being sent to the wrong client stream when multiple TUIs are attached; it also adds guarded handling for malformed JSON frames so one bad frame does not instantly abort all sessions.
ContributionPrevented cross-connection protocol corruption by only adopting a singular fallback sender when it is closed, retaining per-connection fanout semantics during register/unregister/send paths, and by making the protocol parser/logging path strip invalid newline-only JSON artifacts and resync at the next newline (up to 16 consecutive corrupt frames) instead of treating one malformed frame as fatal.
ImpactOperators running multiple attached clients on the shared-server can avoid all connected TUIs dropping together from one malformed event, so collaborative sessions remain usable during long debugging or workflow windows instead of forcing broad reconnects after sudden disconnect storms. The server now avoids rewiring to stale/incorrect writers during concurrent session activity and handles isolated frame corruption as recoverable, so the immediate practical benefit is fewer full-session outages; watch for any remaining code paths that still assume one global fallback sender and monitor repeated malformed-frame sequences for an upstream formatting regression.
This PR adds a Windows-only `shell` flag to all `spawnSync` calls that invoke `npx` in `ruflo-cost-tracker`, preventing Node 21+ on Windows from failing with `ENOENT` and letting cost-tracking commands execute successfully.
ContributionPatched 15 `spawnSync` call sites across seven cost-tracking scripts (`track`, `budget`, `summary`, `conversation`, `export`, `federation`, `outcome`) so `npx` invocations use `shell: process.platform === 'win32'` on Windows while preserving `shell: false` behavior on POSIX.
ImpactWindows users of `ruflo-cost-tracker` will now get reliable `cost track/summary/report` results instead of silent failures that looked like valid-but-empty cost data (`Persisted: FAILED` and `$0.0000`), which makes budget and optimization checks usable again in CI and operator workflows. The fix works by accounting for Node 21+ `.cmd/.bat` launch restrictions by turning on shell mode only on win32 for `npx`, with no behavioral change for non-Windows environments. Continue watching for two follow-ups: whether future Node versions alter Windows shell-launch semantics, and whether issue #2073 in `@claude-flow/cli` (`memory retrieve/export` returning null entries) is fixed, because read-path reports can still be incomplete even when spawn succeeds.
A new `praisonai doctor packaging` diagnostic command is introduced to catch Windows-specific installation and entry-point problems (including `python -m praisonai` vs `praisonai` execution mismatches) before users hit runtime daemon failures.
ContributionIntroduces a concrete diagnostic capability for installation integrity on Windows: a canonical self-check workflow that validates package structure, `__main__` entry presence, version/CLI execution paths, packaging metadata, and Windows-specific environment context (venv/PATH/encoding), helping operators detect launch-blocking issues from inconsistent invocation methods.
ImpactWindows users and operators can now run a dedicated packaging health check before execution, so broken daemon starts caused by mismatched install or invocation paths are detected earlier and onboarding failures become less common. Technically, the change adds a new `praisonai doctor packaging` command and expands Windows entry-point validation with explicit checks (`praisonai --version`, `python -m praisonai --version`, `__main__.py`, command-path resolution, venv/PATH/encoding/context analysis), and follow-up should verify whether these checks produce false positives on customized environments or overly strict gating in CI for nonstandard setups.
The PR changes `vitest` from `pool: "threads"` to `pool: "forks"` with `maxForks: 8` for `npm run verify`, so each test file runs in its own Node process and keeps its own heap. This removes the shared-process memory cliff on 16-core Windows hosts where ~15 threads × ~300MB each exceeded Node’s ~4GB cap, which caused `Zone Allocation failed`, `spawn UNKNOWN`, dashboard timeouts, and `jobs.tailLines` mismatches; after the change, 3412 tests in 244 files passed without OOM or spawn errors.
ContributionImplemented process-level test isolation by changing Vitest from shared-thread workers to forked worker processes (8 max forks), directly fixing the memory-sharing failure mode that made large-core verification runs unstable. This makes CI and local checks deterministic under high core counts by preventing tokenizer/tree-sitter/sqlite state from stacking into a single heap limit.
ImpactOn many-core Windows CI agents and developer machines, `npm run verify` is much less likely to fail with random mid-run crashes, so teams can complete the same test gate with fewer retries and less manual triage. The fix reduces operator pain from flaky failures but increases wall-clock time about 20% (62s to 74s), so teams should monitor whether 8 forks is still the right cap as repository size and host resources change.
A bug in memsearch v0.4.1 makes the stop hook persist any non-empty Claude CLI output as a turn summary, so Anthropic rate-limit/auth errors are written into `.memsearch/memory/<date>.md` as real bullets and then indexed into vector search, degrading retrieval quality. The primary needed change is to validate summarization output and avoid storing error text.
ContributionIntroduce explicit validation in the summarization path: detect non-summary responses from `claude -p` using error-pattern checks (e.g., "hit your limit", "rate limit", "Authentication", 401/403) or bullet-format checks, then skip writing a fake summary and emit a clear placeholder so the turn can be identified and optionally retried.
ImpactOperators on plan-tier Anthropic accounts will no longer get rate-limit or auth error messages silently inserted as true memory bullets, so semantic search and progressive disclosure stay cleaner and more trustworthy during normal use, while still preserving a visible marker for failed turns; monitor whether the heuristics miss new error message formats or suppress legitimate short summaries and whether retry/placeholder handling actually restores those turns. The current hook writes every non-empty response because it only checks for emptiness, making this change necessary to prevent silent pollution of persisted memory and downstream retrieval.
The change makes `EventStream._process_queue()` take a locked snapshot of the subscriber map before iterating, removing a concurrent modification window where `unsubscribe()` or `close()` could mutate the live dictionary during event dispatch.
ContributionIt introduces lock-protected snapshot iteration for event notifications and makes subscriber cleanup resilient to duplicate cleanup paths, preventing the stream from being iterated while shared state is being mutated.
ImpactDevelopers and operators running OpenHands agents are less likely to see intermittent event-stream crashes or dropped session notifications when subscribers are removed while events are being dispatched, so long-lived agent sessions can stay stable without manual restarts. This is achieved by removing a race between `_process_queue()` and concurrent `unsubscribe()`/`close()` operations that previously touched the same mutable subscriber container. Watch for any remaining non-synchronized accesses to shared event-runtime structures that could still introduce similar teardown-time races under heavy concurrency.
The burst’s main change is a fix to drain the performance entry buffer during long-running Ink sessions, preventing memory growth from reaching out-of-memory failure.
ContributionImplemented explicit draining of the performance entry buffer to bound memory retention over time, directly addressing an out-of-memory condition in long-running sessions.
ImpactLong-running Ink sessions are less likely to crash with out-of-memory errors, so developers and operators using nanocoder can keep tooling sessions stable for longer without interruption or forced restarts. Technically, this change prevents unbounded accumulation in the performance entry buffer; continue monitoring whether high-throughput or very long sessions still show near-OOM behavior, whether buffered telemetry completeness degrades, and whether buffer-drain frequency introduces latency or overhead regressions.
This pull request upgrades agor’s turbo dependency from 2.9.8 to 2.9.14. The primary impact is security-driven: the included Turborepo release line adds fixes for a high-severity VSCode extension command-injection issue and additional auth/Yarn-detection hardening advisories, so the change is a targeted toolchain hardening rather than a feature addition.
ContributionThe update brings in upstream Turborepo security patches into agor’s dependency chain by moving from 2.9.8 to 2.9.14, specifically addressing command execution and callback/state security paths that were vulnerable in earlier versions.
ImpactDevelopers and operators using agor’s build pipeline are less exposed to tooling compromise scenarios (for example, repo-linked VSCode commands or auth flow handling being abused), so day-to-day CI and local dev usage is expected to be safer after upgrade. This is worth monitoring because it is a dependency-level jump, so teams should verify turbo command behavior, extension interactions, and Yarn detection steps after merge to catch any workflow regressions from the upgraded internals.
Agor now auto-copies each set `GIT_AUTHOR_*` environment variable to the matching `GIT_COMMITTER_*` only when that committer variable is not already provided, preventing commits from inheriting the executor host’s git identity and avoiding author/committer mismatches in PR metadata.
ContributionIntroduces a deterministic identity-resolution fix in the process environment builder: missing committer identity vars are now filled from author vars so git no longer falls back to host system identity. This directly addresses the root cause where PRs could appear with one author and a different committer, while still honoring explicit `GIT_COMMITTER_*` values.
ImpactOperators and reviewers using Agor will see commit and PR identity remain consistent when they configure only author metadata, so accountability in commit attribution is preserved and audit/review trails are less confusing. The change is implemented by setting `GIT_COMMITTER_*` from `GIT_AUTHOR_*` when absent, replacing host `~/.gitconfig` fallback behavior; watch for environments that intentionally depended on that fallback and for sessions with only partially provided author fields, since those should still be validated for correct identity outcomes.
This change replaces hashline’s stale-anchor repair flow, which previously used fuzzy 3-way merge, with a deterministic two-tier recovery path: direct apply when anchors still match, then structured line-shift correction, and finally corrected-anchor retry feedback using explicit remapped hash anchors. The result is a safer edit workflow that avoids silently writing wrong content when files change after being read.
ContributionIntroduced a deterministic stale-anchor recovery mechanism that first validates direct anchor matches, then applies a strict structured shift map against current file content, and only then falls back to corrected-anchor feedback with a rewritten edit; additionally hardened anchor parsing for malformed numeric/range payload forms to prevent ambiguous or confusing edit errors.
ImpactDevelopers and operators relying on automated edits now avoid silent wrong-content merges when a file changes between read and write, so patch automation is safer and failures become recoverable instead of producing hidden corruption; technically, fuzzy matching is removed, pre-shift remapping is conservative and must be exact, and fallback now requires explicit corrected retry while full-file snapshots are refreshed after successful edits, so watch for fallback frequency and patch-mode escalations in rapidly changing files.
Superlog announced a product focused on replacing manual observability setup with a self-installing workflow, including daily automated logging configuration and an AI agent that investigates errors and opens pull requests for fixes.
ContributionIntroduces an end-to-end automated observability loop: setup and maintenance of logging/monitoring is reduced to a wizard-driven flow, while incidents are analyzed by an agent that proposes remediation as PRs instead of only producing alerts.
ImpactDevelopers and operations teams can spend less time configuring and maintaining telemetry pipelines and more time shipping fixes, because observability is meant to run with minimal manual setup and connect detected errors to candidate code changes. The practical upside is faster incident response and less alert fatigue, but continuation risk includes whether investigation context is deep enough across services, how often auto-suggested PR fixes are correct, and whether data handling and residency for logs/telemetry remain transparent in production use.
This PR focuses on making mirrord preview environments more resilient by updating operator behavior so preview pods are health-checked and rescheduled within the TTL window after crashes or evictions, reducing stale/unavailable previews.
ContributionAdds a concrete reliability fix: health-driven preview recovery in the operator, where failed or evicted preview pods are automatically rescheduled and preview status is aligned to live-running instances.
ImpactDevelopers and operators using mirrord previews should experience fewer failed or stale preview sessions after pod crashes or evictions because failed previews are meant to be detected and recovered instead of lingering in an unusable state. The operator-level change ties recovery and visibility together so dead previews are less likely to remain visible and trigger manual intervention. Watch for false-positive health checks and rescheduling loops under flapping workloads, and verify that TTL timing does not create restart storms.
The PR adds explicit validation for duplicate entries in `incoming.port_mapping` and `listen_ports` so config generation now fails with a clear duplicate-port error instead of silently keeping only one mapping when duplicates exist.
ContributionIntroduces a concrete configuration validation rule that detects duplicate source/target ports for incoming mappings and duplicate `listen_ports` before mapping construction, preventing BiMap’s implicit overwrite behavior from hiding misconfigurations.
ImpactDevelopers and operators using mirrord network forwarding can catch bad port rules immediately, avoiding silent routing misconfigurations where one duplicate mapping vanishes and traffic is sent to the wrong local/remote port during debug sessions; this is especially important in environments where a single dropped rule can block access to a service. The change now rejects duplicate entries during config generation with explicit messages, so teams should watch for CI pipelines or templating tools that currently emit duplicate ports and may start failing builds until inputs are cleaned.
This change refactors mirrord’s OperatorApi to return the established operator protocol connection as a plain `Stream+Sink` type, so the CLI can work with both `mirrord-protocol-io` and `mirrord-protocol-api` during protocol integration.
ContributionOperatorApi was changed to expose operator connections through a generic `Stream+Sink` interface, decoupling CLI transport typing from a single protocol implementation and allowing integration code to target either protocol crate without wrapper adaptation.
ImpactDevelopers maintaining or extending the mirrord CLI should see easier protocol integration and less refactor churn, since the operator connection now has a single reusable interface that can be consumed by both protocol backends. Watch for compatibility fallout during rollout: compile errors in downstream call sites, subtle behavior differences in operator message flow, and dependency-version mismatches between `mirrord-protocol-io` and `mirrord-protocol-api`.
This PR fixes a Windows-specific command-handling bug in pi by adding `normalizeNulRedirects()` for win32, which rewrites unquoted `> nul`, `>> nul`, `1> nul`, `2> nul`, `&> nul`, and `&>> nul` forms to `/dev/null` so Git Bash/MSYS2 no longer creates a real `nul` file during AI-generated command execution; this is important because it prevents silent workspace pollution and keeps command semantics closer to expected null-device behavior.
ContributionAdded a win32-only shell-command normalization pass that detects unquoted NUL redirection targets and preserves the original redirection operator while remapping them to `/dev/null`, directly preventing accidental creation of a `nul` artifact path.
ImpactWindows users running `pi`-generated commands in PowerShell or other Windows terminals avoid unexpected `nul` files, so automation and interactive runs are cleaner and less likely to be disrupted by accidental file writes when redirecting output to discard it; watch for any scripts that legitimately expect a literal filename `nul` or custom redirect patterns not covered by the new matcher.
This PR adds a Windows-only command-normalization step that converts unquoted `nul` redirections to `/dev/null` (`>`, `>>`, `1>`, `2>`, `2>>`, `&>`, `&>>`), preserving the original operator behavior so `pi` commands run correctly in Git Bash/MSYS2 environments.
ContributionIntroduced a dedicated normalization pass for Windows command strings that rewrites redirection targets from `nul` to `/dev/null` outside quoted text, including common stream/operator forms, to prevent accidental file creation while keeping redirection semantics intact.
ImpactWindows users running AI-generated `pi` commands in PowerShell or similar terminals are less likely to get an unexpected `nul` file from redirections, so automation workflows and scripts stay stable and directories stay clean without manual cleanup. The change is explicitly scoped to win32 and excludes quoted patterns to avoid altering literal text; it should be monitored for compatibility with less common redirection variants and alternative Windows shells that may interpret null-device redirections differently.
Variant C of the fix removes `test-smell-detection` and makes `test-anti-patterns` the sole smell-audit skill in dotnet-test plugin mode, migrating the smell catalog and the four `test-smell-detection` eval cases into the remaining skill to prevent competing activations.
ContributionConsolidates two overlapping public audit skills into one: `test-anti-patterns` now covers all smell-audit triggers, while `test-smell-detection` is deleted and its moved catalog/tests/fixtures are absorbed so plugin-mode no longer has ambiguous skill competition.
ImpactDevelopers running test quality auditing in dotnet-test plugin mode can expect more stable, predictable activation of smell checks because a single umbrella skill now owns the behavior previously split across two competing entries. This directly reduces cases where one smell-check skill is selected over another during automation, while maintaining coverage by porting the deleted skill’s 19-smell taxonomy references and four evaluation scenarios into the surviving skill’s suite. Teams should watch for breakage in consumers that call `test-smell-detection` by name, and continue validating end-to-end `/evaluate` outcomes to ensure the unified skill behaves correctly in real pipelines.
An open GitHub issue reports a user-facing regression in Superset’s terminal rendering where Claude code output appears corrupted (gibberish) or duplicated multiple times, making the displayed AI output unreliable for copy/paste and interpretation.
ContributionThis issue identifies a concrete correctness bug in the Superset terminal output path, not just a cosmetic change: rendered text for Claude responses can be malformed or replayed, which directly breaks trust in terminal-visible AI outputs.
ImpactDevelopers and operators using the Superset terminal for Claude code workflows may misread or act on corrupted output, so debugging and workflow safety are reduced until rendering is fixed. The report points to a likely output-render pipeline regression that can duplicate or garble streamed frames, so teams should track whether this reproduces consistently by browser/session and whether it is tied to long outputs, repeated streaming chunks, or specific terminal refresh conditions.
The PR changes stop handling so that when users click Stop while a remote WebSocket session is still establishing, the cancellation error is caught inside each SendBox `handleStop` path and no longer bubbles to the global `onunhandledrejection` flow, preventing the prior `/cancel failed (500)`-style error escalation.
ContributionIntroduced explicit catch handling for cancel failures in all five SendBox `handleStop` implementations (acp, remote, aionrs, nanobot, openclaw), so best-effort stop requests made during WS connect do not propagate as unhandled rejections and UI cleanup still executes through existing `finally` logic.
ImpactUsers pressing Stop during a remote session startup no longer see noisy failure behavior in the client/observability path, so cancellation stays responsive and the chat UI continues to recover cleanly instead of surfacing spurious `/cancel failed` error events.
In this release, mirrord changes HTTP protocol detection on redirected connections to use a bounded read timeout (default 2 seconds, configurable) instead of waiting indefinitely for the first byte, preventing stalls for server-first protocols.
ContributionImplemented a finite, configurable read-timeout guard for HTTP protocol detection on redirected traffic, replacing unlimited first-byte blocking with a 2-second default and explicit timeout knobs.
ImpactOperators and developers using mirrord for redirected HTTP traffic can avoid sessions hanging indefinitely on server-first protocols like SMTP, so traffic no longer appears frozen during detection. The change enforces a bounded wait for the first response byte and therefore improves operational responsiveness, but teams should monitor whether the 2-second default is too aggressive for slow or high-latency endpoints and tune the timeout via agent.http_detection_timeout or MIRRORD_AGENT_HTTP_DETECTION_TIMEOUT if false timeouts appear.
The PR changed `firstLine()` in `internal/watcher/webhook.go` to ensure truncated subject text always ends on a valid UTF-8 boundary (max 200 bytes), preventing invalid byte sequences from being written to `watcher_events.subject`.
ContributionImplemented a concrete UTF-8-safety fix for subject truncation by post-trim validation and byte-backoff logic, and added focused tests covering Cyrillic, em-dash, emoji, boundary-aligned, and newline-before-cap cases.
ImpactWebhook consumers and event operators avoid stalled forwarding loops caused by poisoned DB rows, so integrations like the Python bridge can continue stateful polling without repeatedly failing on the same row every 2 seconds. The change enforces validity-correct subject truncation by removing up to three trailing bytes after a 200-byte cap, which blocks downstream `sqlite3` UTF-8 decoding crashes; continued monitoring should verify no other event fields/callers can introduce malformed UTF-8 and trigger similar reprocessing backlog patterns.
The PR fixes a bug in mirrord where IPv4-only Kubernetes pods with only `::1` as an IPv6 address skipped IPv6 availability detection, so localhost connections using IPv6 loopback were not captured by mirrord steal/mirror and bypassed local redirection.
ContributionAdjusted IPv6 availability logic to stop excluding loopback addresses, so mirrord now treats `::1` as sufficient IPv6 presence and installs IPv6 OUTPUT NAT rules even when the pod lacks global IPv6 interfaces, ensuring localhost IPv6 traffic is captured instead of leaking to the in-cluster app.
ImpactDevelopers and operators using mirrord with Go-sidecars or localhost-based tooling in IPv4-only clusters will stop losing request capture, because `localhost`-resolved IPv6 traffic (`[::1]:port`) will be mirrored to the local machine instead of bypassing diagnostics and observability flows. This is done by enabling IPv6 redirection setup when loopback is present, so the previous silent miss path is removed; teams should verify no regressions in mixed IPv4/IPv6 clusters and watch for unintended effects with existing IPv6 firewall rule sets.
Fixes a correctness bug in google/adk-go where `RunAgentRequest.stateDelta` was accepted by `/api/run` but not applied, causing resumed runs to ignore caller-provided state updates.
ContributionAdded `applyStateDeltaIfPresent` and wired it into both `RunHandler` and `RunSSEHandler` so non-empty `stateDelta` is appended as a session event before agent execution, then merged into subsequent `Get()` state; includes a shallow-copy of the delta map to prevent request mutation from altering stored session event data.
ImpactClients and operators using `/api/run` or `/api/run/sse` for resume workflows will now get expected session context updates before the agent starts, so reruns no longer silently proceed from stale state and recoverability improves for long-running conversations. The fix now records `stateDelta` as a session event through `sessionService.AppendEvent` before execution, and teams should watch for edge cases in event ordering and malformed/rapidly changing `stateDelta` payloads that could still affect merge behavior at high scale.
This PR changes the `run-tests` skill definition so plugin-mode can reliably select it in routing-heavy scenarios, replacing a low-signal block of ~30 generic trigger phrases with five scoped decision-oriented clauses to reduce false misses and wrong activations.
ContributionRefactored the `run-tests` SKILL.md prompt surface from a generic keyword pile to five high-signal scope clauses (e.g., VSTest vs MTP syntax and SDK/version-specific option patterns), directly improving how the skill is matched when many skills are loaded in plugin mode.
ImpactDevelopers relying on dotnet/skills in plugin mode will be less likely to see the `run-tests` skill fail to activate for test-related requests, so automated testing workflows should require fewer manual fallbacks and stay on the intended path; monitor the next scheduled eval and adjacent run-tests scenarios for regressions into new false positives/negatives.
A wrong function name in the skills manager import caused an ImportError that blocked all skill lifecycle operations; correcting `get_default_skill_directories` to `get_default_skill_dirs` restores `create_skill`, `edit_skill`, `delete_skill`, `patch_skill`, and `write_skill_file` so the feature works again.
ContributionThis is a concrete correctness fix that removes a runtime ImportError by aligning the imported helper name with the actual implementation, which directly restores basic skill management behavior and prevents failed skill operations from halting workflows.
ImpactDevelopers and operators using PraisonAI skills can now execute add/edit/delete/patch/write skill workflows without import-time crashes, so automation and manual maintenance of agents can proceed instead of failing unexpectedly. The patch swaps the bad import name for the correct one (`get_default_skill_dirs`), and teams should keep an eye on future renames or refactors in skill modules because another import mismatch could reintroduce the same class of outage.
The PR upgrades the /frontend lint dependency group to newer releases of three plugins, with the primary change being a move to ESLint 10-aligned versions (including eslint-plugin-i18next 6.1.4 and eslint-plugin-unused-imports 4.4.1, plus eslint-plugin-query 5.100.10) to keep the frontend lint stack from falling behind current ESLint support.
ContributionBumped the three /frontend ESLint plugins in one grouped dependency update, moving to versions that add explicit support and fixes needed for ESLint 10 usage (including flat-config typing support and ESLint-10/peer-dependency compatibility updates), which is the concrete mechanism for reducing upgrade friction in the lint toolchain.
ImpactFrontend developers can run ESLint-based lint checks with a higher chance of succeeding on newer toolchains, so local development and CI are less likely to fail due to plugin incompatibility during ESLint upgrades. After deployment, teams should watch for new or stricter lint results introduced by these plugin upgrades—especially around flat config behavior—and verify custom scripts and CI pipelines still pass consistently.
The report identifies a single primary defect: cc-connect’s agent stdout read loops for codexSession and claudeSession can terminate a live session when output contains a line over ~64KB, matching the Go `bufio.Scanner` token-length failure mode. Repeated logs show both sessions returning `bufio.Scanner: token too long` and dropping the session after long JSON/JSONL lines.
ContributionThis issue contributes a concrete correctness finding: the stream parser path has an implicit hard limit from Go scanner defaults and lacks resilience for oversized lines, so the suggested fix is to expand/parameterize the buffer or replace scanner-based line reading with a streaming approach that can warn and continue on overlong non-JSON lines instead of terminating the session.
ImpactOperators running cc-connect with codexSession or claudeSession can lose in-progress agent sessions when tools emit large one-line outputs, which can break prompts, pipelines, or long autonomous tasks that rely on uninterrupted stdout streaming. The underlying mechanism is the read loop’s use of `bufio.Scanner` with its default token cap, so watch for whether implementations switch to bounded, configurable handling that degrades safely (warning/truncation/fallback) without dropping the whole session, while also checking for any memory-growth risks from raising limits too aggressively.
Within this mixed 5-commit burst, the key change is a security update: OpenHands updates pypdf to version 6.10.2 to address CVE-2026-41312. The update targets the repository’s PDF parsing dependency used in document-handling flows.
ContributionUpdated the pypdf dependency to 6.10.2 to remediate the CVE-2026-41312 vulnerability in PDF processing.
ImpactDevelopers and operators handling user-supplied PDF files in OpenHands are less exposed to known parser-security risks, so hostile PDFs are less likely to trigger exploitable behavior during ingestion; keep an eye on PDF upload/parsing regressions and confirm security-focused regression tests pass after deployment. This change narrows the vulnerable code path by replacing the vulnerable pypdf version with the patched release.
Refactor the InsForge backend startup flow so importing `backend/src/server.ts` no longer starts the service; app creation is moved to `backend/src/app.ts` and `initializeServer()` in `server.ts` only runs when the module is the process entrypoint, with a regression test added for import-safe behavior.
ContributionSplit app initialization from runtime startup by extracting Express setup into `app.ts`, adding an entrypoint guard in `server.ts` so startup and signal handlers only register when executed directly, and adding a test that import does not trigger server boot or handler registration.
ImpactDevelopers and automated test/jobs can import backend server code without unintentionally launching the HTTP process, so local tests and tooling stop blocking on already-bound ports or lingering processes during import. Technically, the startup path is now isolated to direct execution of `server.ts` via `isEntrypoint()`, while `createApp` remains exported for compatibility from the entry module; operators should continue watching whether all valid launch entrypoints still call the startup path correctly and whether any remaining module imports still perform other hidden side effects during load.
The change rewrites generated Superset agent launch commands to stop using bash-only heredoc/cat-command-substitution prompts and instead pass prompts as one shell-quoted argument or via a `printf` stdin pipe, then updates shared and host-service tests plus launch-context docs to enforce this behavior.
ContributionChanged the command-generation path for agent prompts from `$(cat <<...)` heredoc transport to either one escaped shell-quoted argv value or `printf '%s\n' '<prompt>' | <agent>` stdin launch, preventing bash-only syntax from breaking prompt execution paths and adding regression coverage around quoted prompt handling.
ImpactOperators and developers running Superset agent prompts from fish or mixed-shell environments will see launch commands execute more reliably, reducing shell-related startup failures and integration breakage from prompt syntax errors; this also lowers the need for shell-specific workarounds in automation. The update removes bash-specific heredoc/cat substitution from generated commands and switches to shell-agnostic argv or printf-based stdin dispatch with updated escaping and regression tests, so teams should keep watching for remaining quote/escape edge cases in nonstandard prompts.
The PR changes `permissionService`’s `skip` flag from an unsynchronized `bool` to `sync/atomic.Bool`, and routes all accesses through `Load`/`Store`, removing a concurrent read/write race between `Request`/`SkipRequests` and `SetSkipRequests`.
ContributionImplemented a minimal, scoped concurrency fix by replacing the plain `skip` field with `atomic.Bool` and updating all reads/writes to atomic operations; added a deterministic multithreaded regression test (`TestPermissionService_SkipRace`) that fails on the race before the fix and passes after it, demonstrating concrete behavior correctness under concurrent writes/reads.
ImpactOperators and developers running concurrent permission checks will get more stable behavior and fewer misleading race failures during testing because the permission skip switch no longer races across goroutines, which reduces nondeterministic skip-path behavior and makes permission flow debugging more reliable. The patch is technically constrained to the `skip` field, so teams should still monitor CI race-detector coverage and inspect neighboring shared state (including other permission/service paths) for similar unsynchronized access patterns.
The release focuses on making dual checkpoint reads resilient: when v2 checkpoint data is malformed or missing, the CLI now routes to a stable v1-based path instead of failing the review/summarization flow.
ContributionAdded a concrete checkpoint-recovery fix that enforces a safer dual-reader fallback, preserving v1 transcript offsets and shared fallback handling so review and reload logic can continue when v2 checkpoint storage is broken or unavailable.
ImpactOperators using the CLI for review, summary generation, or reloads can avoid hard failures when checkpoint data is partially corrupt or missing, so workflows keep progressing with fewer manual recoveries. The code now explicitly tightens dual-checkpoint fallback, centralizes committed checkpoint reads, and keeps v1 transcript offsets intact during fallback; teams should watch whether fallback frequency rises sharply (possible data-quality regression) and whether outputs produced via v1 recovery match normal-path outputs in accuracy-sensitive runs.
AionUi PR #2936 changes conversation navigation so that a deleted conversation ID returning 404 is handled in the fetcher instead of bubbling as an unhandled rejection, shows a single `conversation.notFound` warning toast, and redirects users to the home page using history replace so the stale route is not re-entered.
ContributionAdded concrete missing-conversation handling in the Conversation index fetch path, converting an unhandled BackendHttpError into a controlled not-found warning and safe redirect, while updating history rewrite logic so back navigation no longer returns users to the deleted conversation URL.
ImpactDesktop users who delete a conversation and then navigate back no longer get stuck on a dead conversation page with repeated 404 failures; they now land on the welcome screen with a clear notice, which directly improves recoverability of everyday navigation flows and reduces crash-like support incidents. The fix works by catching the conversation fetch failure in `ConversationIndex`, preventing SWR from re-throwing it as an unhandled promise rejection, and using `replace: true` navigation plus `NavigationHistoryContext` cursor rewriting to keep the invalid route out of history; next, monitor whether other 404 conversation paths still leak to Sentry (especially ELECTRON-19G) and whether any legitimate back-navigation behavior regresses after the replace-based redirect.
The pull request changes the OpenAI stream error path by adding a defensive `response.text()` wrapper with a 5-second hard timeout and by making retry logic aware of hard-quota signals, including large `Retry-After` values. This prevents the coding agent from getting stuck on non-200 responses and stops auto-retry loops when the provider signals a hard usage limit.
ContributionIntroduced a quota-aware failure path for streaming completions: non-200 responses now return an error within 5 seconds instead of hanging, and auto-retry is disabled for hard quota indicators or excessive retry windows (over 300 seconds), while still permitting normal transient rate-limit recovery.
ImpactOperators and users of the coding agent will see rate-limit failures fail fast instead of freezing in a perpetual "Working" state, so tasks no longer consume resources in endless retries when a provider has reached hard usage limits. The fix adds explicit extraction of `Retry-After` into error details and enforces a 5-second timeout on error-body reads, which reduces UI lockups and avoids retry storms on opaque upstream connection failures; teams should watch for regressions if providers rely on slower-error response patterns or if retry-window thresholds are too conservative for future billing or provider semantics.
aider now wraps three path-check call sites in `aider/main.py` with `try/except OSError` so malformed or overlong filenames no longer crash the process during file/directory validation.
ContributionIntroduced defensive exception handling around `Path` directory checks in three main execution paths, converting unhandled filesystem failures into user-friendly warnings and graceful skipping of bad paths.
ImpactUsers and operators who run aider with very long or malformed path inputs avoid abrupt crashes, so CLI sessions continue instead of exiting with an exception when a single bad filename is encountered. This matters when commands are automated or involve many files, because invalid paths are now contained as warnings while the rest of the workflow can proceed; watch whether other path operations (for example resolve/stat calls in adjacent code paths) still surface uncaught filesystem errors on edge-case filenames.
The PR fixes local `brv query`/`brv curate` outcome messaging by separating true ByteRover login failures from other provider auth errors and by turning blocked or no-op curate responses into explicit errors instead of false successes.
ContributionIntroduces targeted UX/error-handling changes for local commands: provider-specific auth failures now display provider credential/base URL guidance rather than `brv login`, while curate execution now distinguishes blocked outcomes as errors and only reports `No context changes applied` for genuine non-mutating successful runs.
ImpactCLI users running local query or curate flows will get clearer, actionable feedback, so they are less likely to run the wrong login flow or assume a blocked curation actually succeeded; this reduces wasted operator troubleshooting and misconfigured reruns. Specifically, this change should improve triage speed by preventing false success signals, while maintenance should watch for cases where daemon error formatting lacks provider context and for any blocked-text patterns that incorrectly trigger the new error classification.
A pull request updates Claude project key generation to treat `.` and `@` as replaceable characters when deriving project IDs, aligning generated keys with Claude Code’s on-disk directory naming and preventing session lookup mismatches that made `/list` return empty for certain workspaces.
ContributionCorrects the project-directory key normalization logic so `encodeClaudeProjectKey()` escapes `.` and `@`, making `findProjectDir()` generate keys that match Claude Code’s saved project folders and restoring session lookup behavior.
ImpactDevelopers using Claude in directories like `.nvm` or scoped package paths such as `@anthropic-ai/claude-code` can now get accurate `/list` session results instead of empty output, which prevents silent failures when they need to resume the right project context. The update keeps session discovery consistent with Claude Code’s naming scheme, and operators should still watch for any other special characters in workspace paths that could remain unmatched and reintroduce silent key drift.
This PR updates OpenCowork’s development dependencies by bumping @types/node from 25.6.0 to 25.7.0 and upgrading both @vitest/coverage-v8 and vitest from 4.1.5 to 4.1.6, consolidating the test toolchain on a newer patch release.
ContributionUpgrades the repository’s test and coverage stack to newer patch versions (`vitest`/`@vitest/coverage-v8` and `@types/node`), which introduces upstream testing bug fixes and diff-path performance changes while aligning dependencies for ongoing maintenance.
ImpactDevelopers running tests in this project can expect a cleaner development/testing flow after this bump, with fewer expected surprises in browser-related test cases and faster test-diff handling during CI and local runs. The update pulls Vitest 4.1.6 behavior, including fixes around screenshot resolve paths and optimized diff stringification, so teams should re-run browser tests, verify screenshot and concurrency-related assertions (`sequence.concurrent` and deprecated `sequential` usage), and check for any Node 25.7 type-compatibility issues before wider rollout.
Added a new `daemon/linger_stub.go` with `//go:build !linux` that defines a `CheckLinger()` implementation for non-Linux targets, resolving the compile-time `undefined: daemon.CheckLinger` error introduced when `cmd/cc-connect/daemon.go` started calling this function.
ContributionIntroduced a dedicated non-Linux stub implementation of `CheckLinger` behind a `!linux` build constraint, separating Linux/systemd-specific behavior from the common build path so the project compiles on macOS and Windows.
ImpactDevelopers and operators on macOS or Windows can now build cc-connect again instead of hitting a hard compile failure, so cross-platform workflows and packaging pipelines can continue without manual Linux-only workarounds. The stub makes `CheckLinger` explicitly return a fallback user value on non-Linux systems, so the team should watch for any callers that later begin relying on real linger-state semantics and validate whether returning `true` remains the right default as system-specific behavior evolves.
`img_2_b64()` now explicitly decodes the Base64 result to a UTF-8-compatible string via `.decode("ascii")` instead of relying on `typing.cast`, preventing a bytes return type at runtime.
ContributionCorrected the function’s runtime behavior by applying an explicit decode step after base64 encoding, so `img_2_b64` now returns a string value consistent with expected downstream string concatenation and serialization usage.
ImpactDevelopers using LlamaIndex image conversion helpers can avoid runtime crashes when their `img_2_b64` output is inserted into `data:image/...` strings or serialized to JSON, which reduces unexpected failures in image pipelines and integrations. The fix replaces a static-type-only cast with a real decode step, closing a mismatch that caused `TypeError: Object of type bytes is not JSON serializable`; operators should monitor for callers that previously expected bytes and ensure regression tests cover JSON/data-uri paths.
This change centralizes committed-checkpoint reads through a shared mode-based reader factory and adds a DualCheckpointReader path that uses v2 first but falls back to v1 raw checkpoint transcripts when v2 full-transcript artifacts are missing. The refactor removes bespoke v1/v2 resolution logic from explain/resume/rewind/restore callers and keeps v2-only compact-transcript reads as a separate path.
ContributionImplements a concrete checkpoint-read fallback behavior for session transcript retrieval: v2 sessions now auto-degrade to legacy v1 raw artifacts when v2 full/transcript metadata is missing, while preserving v2-only compact transcript behavior where valid.
ImpactDevelopers and operators running explain/resume/rewind/restore in mixed v1-v2 checkpoint repositories can avoid command failures caused by missing v2 transcript artifacts, so incident recovery and long-running agent workflows are less likely to halt due to migration gaps. Technically this is done by routing all committed-checkpoint reads through a shared mode-aware factory with dual-path fallthrough; teams should continue to watch offset accuracy and mixed-repo fallback boundaries to ensure fallback content is correct and that missing v2 data is surfaced instead of silently masking upstream data issues.
A single correctness-focused change adds empty-response checks before indexing `response.choices[0]` in 16 callsites across multiple `llama_index` LLM integrations, replacing unsafe direct access that could crash with `IndexError`/`AttributeError` when providers return no choices (issue #21337).
ContributionImplemented a concrete safety guard pattern (`if not response.choices`) across all identified unguarded response-access sites, so empty-choice provider replies are handled as explicit validation errors instead of implicit runtime failures.
ImpactApplications and teams using these `llama_index` providers will fail more predictably when an upstream model returns an empty completion, which reduces production incidents from ambiguous crashes and makes error handling/retries easier to automate. The patch changes 16 direct `choices[0]` dereferences to explicit checks and converts failures into a clear `ValueError`, but operators should watch for two adapters (Azure Inference and MistralAI) that still show incomplete pact proof status and ensure downstream code handles the new error type consistently.
The PR fixes a path bug where the research toolkit hardcoded a maintainer-specific VAULT_PATH, causing other users’ note saves and obsidian:// links to target a non-existent vault. It now reads OBSIDIAN_VAULT_PATH via existing project conventions and setup.sh writes that variable into the research .env, so standalone CLI runs resolve a valid vault location.
ContributionReplaced the hardcoded VAULT_PATH with required-config loading of OBSIDIAN_VAULT_PATH in scripts/research/lib/config.py, and updated setup.sh to persist this env var into the research .env for standalone CLI usage.
ImpactUsers running the research commands can now write /youtube, /research, /research-deep, and /notebooklm notes into their own Obsidian vault instead of a nonexistent personal path, so notes are no longer silently misplaced and generated obsidian:// links stop breaking; we should keep watching environments where OBSIDIAN_VAULT_PATH is not provisioned because the new path check fails fast with a standard error and will surface setup gaps immediately. Technically, the PR removes the hardcoded value and uses get_required to enforce OBSIDIAN_VAULT_PATH as the runtime source, while setup.sh now writes that variable into the research .env so non-shell-initialized CLI invocations can still resolve the vault path.
Serena released v1.5.1 as a hotfix that resolves a reported onboarding tool defect (referenced in issue 1503), targeting blocked or failing setup flows in the repository’s onboarding path.
ContributionApplied a release hotfix that corrects the onboarding tool behavior reported in issue 1503, restoring the normal onboarding workflow in v1.5.1.
ImpactDevelopers and operators using Serena’s onboarding flow can complete environment onboarding more reliably after upgrading to v1.5.1, reducing blocked setup attempts and the need for manual workaround steps. The fix appears scoped to the onboarding workflow path itself; continue watching first-run onboarding success rates, environment-specific onboarding failures, and whether any new startup exceptions appear in subsequent usage.
The PR fixes packaging by running `npm install --production` during `scripts/build-hooks.js` and adding `plugin/node_modules` to the package `files`, so runtime modules such as `zod`, `shell-quote`, and `tree-sitter-*` are shipped with the marketplace bundle instead of being omitted at publish time.
ContributionImplemented a packaging change that materializes plugin runtime dependencies during build and includes them in the published payload, which directly addresses missing-dependency runtime failures in end-user installs.
ImpactUsers and operators on macOS/Windows are less likely to lose prompt sessions silently after upgrades, because the plugin package will now include the runtime modules needed for the worker to start and summarize sessions correctly. Technically, the build now performs a production install in `plugin/` and marks `plugin/node_modules` as distributable, replacing prior bundles that omitted those dependencies; continue watching for build-time drift in dependency sets, potential package-size impact, and whether install/signals are fully visible in mobile clients where hook errors were previously hidden.
Updated `get_volume_file_metadata` to handle RFC 7231 HTTP-date strings from `files.get_metadata()` by parsing them to ISO 8601 before returning `last_modified`, with fallback to the raw value when parsing fails, instead of calling `.isoformat()` on a string.
ContributionImplemented a concrete timestamp-shape fix in `get_volume_file_metadata`: string `last_modified` values are now normalized to ISO 8601 via `parsedate_to_datetime`, aligning output with existing list-file behavior and preventing crashes from API type inconsistency; added unit coverage for real SDK string input, `None`, and invalid strings.
ImpactOperators and developers consuming Databricks volume metadata now avoid unexpected job interruptions when metadata fetches hit SDK string timestamps, so file-syncing, indexing, and automation pipelines are less likely to stop on `AttributeError` during normal runs; the PR also adds defensive handling of unparsable values, and should be watched for future SDK changes in `last_modified` typing or date format that could reintroduce parsing regressions.
This PR adds immediate reporting of syntax and linting problems when modifying TypeScript or JavaScript files in Serena, turning edits into a validation point instead of deferring issues to later build or review stages.
ContributionAdded diagnostic emission on TS/JS file modification so Serena now surfaces syntax and lint violations directly during write/edit operations, not only after the fact.
ImpactDevelopers editing TypeScript or JavaScript in Serena will see immediate error feedback, so invalid code is caught earlier and does not propagate into subsequent testing or CI failures. Serena now runs/forwards syntax and lint checks as part of the file-write flow, and teams should watch for false positives, missed error cases, and any slowdown on large file updates.
The PR changes `get_process_cwd` in abtop to call `lsof` with `-a`, so `-p <pid>` and `-d cwd` are applied together on macOS; this prevents parsing a cwd line from another process and avoids incorrectly dropping OpenCode sessions.
ContributionIntroduced a concrete correctness fix in the process-cwd lookup path by forcing `lsof` to combine PID and cwd selectors with `-a`, so session correlation no longer uses stale/foreign cwd entries during DB directory matching.
ImpactOn macOS, operators using abtop with OpenCode session tracking can avoid intermittent session drops because cwd lookup now targets the intended process rather than accidentally reading another process’s cwd line, so session rows stay correctly associated and operational visibility is more stable. The change alters command filtering behavior in `get_process_cwd`; teams should monitor macOS `lsof` output/flag behavior on new environments to ensure the parser still receives stable, correctly scoped cwd entries and no silent mismatches reappear.
In release 3.210.0, mirrord-agent hardens startup networking by switching from a dual-stack IPv6 client listener to IPv4 when IPv6 listener setup fails (e.g., on IPv6-disabled clusters), reducing startup-time connectivity breakage.
ContributionIntroduced a concrete network fallback path in the agent: failed dual-stack IPv6 listener initialization now triggers an IPv4 listener path, preventing reliance on an unavailable IPv6 path and improving reliability for agent-mediated connections.
ImpactDevelopers and operators using mirrord on clusters with limited or flaky IPv6 support are less likely to hit session startup failures, so service traffic through mirrord is more usable without manual protocol workarounds. The agent now degrades from a dual-stack IPv6 listener to IPv4 and keeps IPv6 resolution from truncating addresses, which should reduce intermittent DNS/connection errors during local debugging and proxying. Continue monitoring clusters that claim full dual-stack capability for repeated IPv4 fallback events, and watch for any remaining IPv6 resolution mismatches in custom DNS/network setups.
dmux v5.8.1 is a bug-fix release focused on reducing attention notification noise by quieting excessive or repetitive attention alerts.
ContributionThis change updates dmux’s alerting behavior so attention-related notifications are less noisy, directly addressing false/redundant alerts rather than changing core model/runtime semantics.
ImpactOperators using dmux will be interrupted by fewer spurious attention alerts, so they can spend less time triaging noise and more time responding to real issues; the v5.8.1 patch appears to reduce repetitive attention warnings produced by the release’s bug-fix path. Continue watching for whether any legitimate attention events get suppressed or delayed under corner-case workloads, and track alert coverage after rollout.
The PR adds the required `name` and `description` YAML frontmatter to `agents/README.md` so automated scanners and Claude Code can distinguish the human-facing documentation file from valid agent definitions, which was previously failing or silently skipping registration.
ContributionIntroduced minimal YAML fields (`name`, `description`) at the top of `agents/README.md` to explicitly mark it as documentation, which prevents the file from being picked up as an agent definition during recursive `.md` discovery.
ImpactDevelopers and operators running agent auto-discovery or repository audits will avoid false positives and silent skips caused by `agents/README.md` being treated as an agent, reducing noisy failures and keeping agent registration behavior predictable. The mechanism is simple metadata tagging that satisfies scanner expectations for required frontmatter fields; next, teams should monitor any newly added documentation files under `agents/` to ensure they also carry explicit metadata and do not reintroduce discovery mismatches.