LoongSuite Pilot release notes

The Doubao App work mode can now reuse the passive collection pipeline of Doubao Workbench. After you explicitly select it with listeners.doubao-work.client, installation detection, log reading, and Trace identifiers remain consistent. The default behavior remains Doubao Workbench.

Multi-modal collection now supports common local video formats. When a user explicitly provides a video file, QwenWork and Qoder reuse the existing upload and structured URI flow while continuing to filter command text and mismatched file content.

AgentLoop audit queries and dashboards now share a unified schema, enumerations, and SQL knowledge. This clarifies the output boundaries for query results, complete SQL statements, and integration materials, and removes the duplicate legacy Solutions directory.

Qoder CLI can collect model and tool activity from native sub-Agents and connect nested executions to the actual parent task. Sub-Agents retain independent turns, usage, and identities, and background task notifications are attributed correctly.

Multi-modal summaries are attached to the corresponding LLM or tool Span. Input, output, and incremental metadata are no longer retained only in raw messages, so you can analyze image and video processing directly from the Trace.

Large transcripts from QoderWork, QoderWork CN, and QwenWork now recover incrementally from byte checkpoints. Complete turns are committed progressively, and oversized content is truncated or skipped at defined boundaries to reduce repeated scans and backlog blocking.

OpenClaw no longer registers a finalize observer that blocks streaming replies. After you upgrade and restart the plugin, in-progress chunks are displayed promptly while the final answer and token usage remain unchanged.

When a native session returns or throws an exception, Hermes closes the turn owned by the current call and retains compression, nesting, and concurrent-call relationships. This prevents premature turn completion during long-running operations and loss of subsequent tool and model records.

Hook, the QoderWork SDK, and the segment reader retain an unchanged incomplete tail and resume reading only after the file changes. Line breaks, truncation, file replacement, and oversized records all recover under bounded rules, avoiding idle polling and repeated parsing.

On Windows, when a watched directory is deleted or replaced, the old watcher closes immediately and remounts after the directory is restored. This prevents stale handles from continually triggering events and causing high single-core usage.

When request-set and preceding-context matching fails, Qoder reads the most recent stop Hook context and retains the task attributes of each turn in a reused session. This prevents trailing control records from losing attributes or leaking them into adjacent turns.

Added an AgentLoop plugin for Qoder. In a conversation, you can generate a Pilot installation package, query collected logs, and preview the audit dashboard locally. The online dashboard is published only after you confirm.

QwenWork can extract local images from pasted images, file selection, and supported tool calling, and generates structured URIs using the existing multi-modal storage configuration. If reading fails, the original event is retained.

pilot_status in the commercial edition adds a summary of managed Worker clients. For each configured instance, it reports Agent types, actual Bundle and plugin versions, local resource inheritance, model configuration modes, and a limited set of failure reasons. The four built-in Runtime Bundles are also updated.

Added Agent system identifiers for OpenClaw, Copilot CLI, Cursor CLI, Kiro CLI, and Qoder CN, improving source identification in OTLP Traces.

Improved the dashboard Skill documentation for filters, variable substitution, and interactive drill-down, and clarified the acceptance boundary between local preview and online controls.

Codex caches and persists stable owner-detection results to avoid repeated scans after a restart or when history files exceed cache capacity. It also fixes an issue where concurrent Worker-status writes could corrupt or overwrite the final status.

Codex uses bounded delayed recovery for failed stop records so subsequent turns can continue processing. When a file timestamp is unchanged but its content grows, Qoder revalidates cached boundaries to prevent old prefixes from being incorrectly joined to new data.

For compatible long turns, OTLP streams conversion by complete steps and promptly releases completed Spans, significantly reducing peak memory for large numbers of model calls and tool calls. Incompatible event ordering still safely falls back to the original batch processing.

DSH JSONL polling retains a read budget and supports bounded recovery of large records. A static partial line waits for the file to change, and the skip position of oversized records persists across restarts, reducing idle repeated reads and long-record blocking.

Added passive observability support for Doubao Workbench. It can reconstruct evidence-backed call chains from local client tasks, model outputs, tool calling, sub-Agents, sandbox execution, and the Windows message lifecycle, while using bounded incremental reads to control resource consumption.

The installer can record installation sources such as qoder-marketplace, agentshell, and other, and can configure user.id from the hostname, username, or email address. Runtime status also reports the installation source, helping distinguish integration channels and user identities.

Qoder and Qoder CN can select the correct account information by client, session, and product, and collect the logged-in user's name and email address to prevent identity mix-ups when multiple products coexist.

Claude Code adds first-response time and system instructions through native session requests, improving the completeness of model-call context and duration statistics.

Insight documentation standardizes Agent display names and adds data-source descriptions, clarifying the sources and applicable scope of analysis results.

Codex limits the workload of high-frequency wakeups and the memory residency of pending turns. It fixes targeted wakeups clearing other sessions' ownership indexes, stalled fork searches, and empty delegation states written at startup.

Codex uses bounded processing for oversized Transcript records to avoid repeated reading of unfinished tails and quadratic memory copying, and supports recovery of complete turns across isolated records.

Qoder Transcript collection now uses bounded incremental parsing, removes the retry child process, and strengthens concurrent wakeups, checkpoint persistence, and delayed Prompt recovery to reduce repeated large-file reads and resource use.

The Qoder installation plugin now parses CLI, App, and IDE identities from the actual SessionStart structure. When account information is unavailable, it safely falls back to the hostname, preventing an incorrect identity from being written and not retried.

Added a GitHub Copilot CLI observability plugin that collects sessions, model calls, tool calling, permission decisions, and token usage data, and improves deduplication for long sessions, delayed data recovery, and local log space governance.

Containers can now complete Hook injection before the business Agent starts, and support build-time Agent lists, runtime overrides, and non-blocking business startup on failure, improving deployment reliability in Kubernetes and init container scenarios.

Codex Hook call duration can now enter the Pilot self-monitoring pipeline, which aggregates call counts, total duration, and maximum duration by Agent and Hook type, making it easier to locate performance issues in the collection pipeline.

Codex subtasks now retain complete upstream work identity, delegated input, and call audit information, and improve the reliability of concurrent update and output retries.

OpenCode collection is now compatible with both V1 and V2 data formats, and improves fault tolerance for incomplete token usage data, tool events, and cleanup scenarios.

Qoder Desktop and Qoder CN now add account metadata, making it easier to identify and correlate user information from different clients during analysis.

The Insight documentation adds value tags, an event model, and reusable query methods, so the routing and metric definitions of analysis skills are clearer.

When Block Mode is neither all nor custom, interception Hooks are no longer written to Qoder and QwenWork CN. An upgrade also cleans up interception Hooks left over from earlier installations, while normal data collection Hooks are retained.

GitHub Copilot CLI history replay is now bounded, and oversized JSONL, debug, and failure logs are segmented and reclaimed, so first-time integration no longer reads excessive historical data and long-running operation no longer fills up the disk.

OpenClaw and Hermes sessions now retain upstream trace correlation across restart and delegation scenarios, and buffer events while the current turn input is not yet ready, reducing loss of parent-child call relationships.

Qoder CN Hooks launched through sh are now correctly redirected to Bash, so Hooks no longer fail to execute because of differences in Shell capabilities.

The initialization image now uses a base image that includes Debian 12 security updates, and production dependencies are updated and redundant dependencies removed, fixing the high-risk issues found by image scanning.

All Agent collectors can now adjust the polling interval uniformly through LOONGSUITE_PILOT_POLL_INTERVAL_MS, and the default interval is optimized to 10 seconds. Listener-based collectors also apply this configuration correctly, which reduces overhead on idle machines and avoids abnormally frequent scans.

Message content is now always collected and is no longer affected by the legacy content switch. After an upgrade you get consistent, complete message data, and legacy configurations remain upgrade-compatible.

Containers can complete Hook injection before the Agent process starts, and keep repairing Hooks within the recorded Agent scope. Hooks that were installed successfully are retained in multi-Agent, multi-user-directory, and repeated installation scenarios.

Request context is now published incrementally, which restores duration statistics for the first Hermes response chunk. Cache eviction retries are limited and the first-chunk lock is isolated, reducing waits and error counts in long-request and concurrent scenarios.

Fixed an issue where concurrent Grok sessions writing to the same JSONL file could interleave, and unified the file locks for Hook installation results and alert markers so that older state no longer overwrites newer results.

When Hook installation fails, the alert attempt now completes within 3 seconds. Network exceptions no longer block the installation process, and alerts that were not sent successfully can still be reported later by the main process.

Collection events from Qoder IDE and Qoder CLI can now carry the signed-in user's name and email, making it easier to identify data ownership in multi-user environments. These fields are safely omitted when the user is not signed in or the query fails.

Sensitive-information interception results now use a dedicated BLOCKED marker, so they are no longer confused with the MASKED marker used for content masking. Callers can now tell accurately whether a request was blocked or only masked.

After an Alibaba Cloud, AWS, or Tencent Cloud AccessKey ID is detected, nearby values that look like secrets can be scanned and masked within bounds. This reduces the risk of leaking credentials that appear together, and the scan scope is limited to control false positives and performance impact.

Multi-modal content can be uploaded through anonymous Simple Log Service (SLS) objects, and bounded recovery and rediscovery continue after a startup probe failure, which reduces prolonged image upload outages caused by transient network or permission fluctuations.

You can configure a workspace collection blocklist during installation. Codex subtask merging and attachment upload also follow the privacy settings of the parent workspace, so you can exclude projects you do not want to collect.

Codex installation, repair, and uninstallation flows now clean up only Pilot-managed Hooks and configurations, and retain third-party legacy Hooks, shared trust state, and existing user assets, so uninstalling Pilot no longer affects other tools.

Supports correlating data from sub-Agents derived from Hermes and OpenClaw to reconstruct complete task chains.

Improves managed default configurations for multi-modal models and keys to reduce the effort required for initial integration.

Adds an option to the macOS menu bar to launch at system startup, making it easier to keep the desktop client running.

The local Dashboard is disabled by default. You can enable it when needed by setting dashboard.enabled=true.

The interception service listens on ports only in full or custom Block Mode, reducing unnecessary resource usage.

Limits the scope of disk scans to reduce startup and inspection overhead in environments with large directories.

Fixes first-response timing statistics and overlapping session fragments for Hermes.

Fixes first-response timing statistics for OpenClaw.

Fixes end-reason identification for DSH to improve the accuracy of session completion status.

Improves delayed retries and multi-modal message processing for Qoder to reduce missing and duplicate data collection.

Uses the built-in Node.js node:sqlite module consistently to simplify runtime dependencies.

Kubernetes distribution packages no longer include native extensions, improving compatibility in container environments.

The Windows ARM64 installation process supports a managed Node.js runtime.

Added a local Agent Interceptor that applies sensitive-information rules to user inputs and tool calling in Qoder Desktop/CLI, QwenWork CN, and OpenClaw. It can intercept API keys, cloud AccessKeys, private keys, and database URLs, and balances availability and security with fail-open behavior, log rotation, and automatic masking.

The commercial edition installer now provides a global multi-modal mode that applies a unified image upload policy to all selected Agents and safely merges existing Simple Log Service (SLS) storage configurations.

Qwen Code can now collect completed foreground sub-Agents and produce recursive Traces that support parallel subtasks, making call chains for complex tasks more complete.

DSH events now include Worker names and instance attributes, making it easier to distinguish Workers in the same environment.

Hooks no longer repeat version detection for Pilot-managed Node.js. Transcript line counts now use byte scanning, and repeated reads of large files are reduced to lower interaction-path overhead.

Codex collection now retains active Transcript metadata to support incremental session processing and state tracking.

Local compilation installations now use versioned safe upgrades, with support for explicit full reinstallation and installation-parameter pass-through. On failure, the previous version and configuration are retained to avoid unavailability caused by uninstalling before installing.

AgentCore Runtime Bundle is updated to 0.0.20 / 0.0.16, incorporating runtime capability and compatibility improvements.

Corrected the masking marker names for IP addresses and bank card numbers to align with SLS conventions.

Codex now prioritizes provider-returned response IDs and supports discovery of user-isolated session directories, improving response correlation and session discovery accuracy.

Deployment now correctly identifies and persists PI_CODING_AGENT_DIR, GROK_HOME, and DSH_HOME, so collection, repair, and uninstallation in containers use the actual Agent directories.

Kubernetes preloading now follows PILOT_PROCESS_FILTER, adds the missing Grok Build Hook resource paths and fixed Node.js paths, and supports flattened data directories.

Added loongsuite-pilot inject --agents=claude-code --config-dir PATH --json to safely inject Pilot Hooks into custom session configuration directories for Claude Agent SDK on Linux and macOS. Existing user configurations and third-party Hooks are preserved, with support for atomic writes and concurrent-conflict handling.

Added the optional mask.replacementMode: "preview" setting. The nine existing categories of masked data can use bounded, recognizable asterisk previews. Fixed placeholders remain the default, and existing configurations are unchanged.

OTLP Trace now supports pre-export Span Enricher plugins that derive business attributes from complete tool fields through local .mjs modules. Multiple plugins run in their configured order, and a single plugin failure does not block export.

Claude Code can optionally propagate W3C Trace context to Anthropic-compatible gateways and attach the gateway Span for each physical request to its corresponding LLM Span. Retries and failures are also recorded independently for each attempt, making it easier to diagnose rate limiting, network errors, and final failures.

Multi-modal storage can reuse a single SLS API key target to complete its configuration. It also supports the delegatedOss shorthand, storage Endpoints that include a Project, and retries for SLS capability detection, reducing duplicate configuration items and Endpoint concatenation errors.

When the watchdog detects changes to config.toml, Codex trust configuration is automatically repaired by reusing deployment health checks while preserving semantically correct existing trust entries. This prevents duplicate tables, retired entries, or user edits from causing repairs to lose valid configuration.

Updated the Claude Code, OpenClaw, Codex, and Qoder CLI AgentCore Runtime Bundles distributed with the package. The update adds Matrix attachment support and includes fixes for cross-drive file replacement on Windows, exit cleanup, and Matrix NUL message handling. The new runtimes are available immediately after installation or upgrade.

QoderWork, QoderWork CN, and QwenWork CN now collect data from native sources. Installation, upgrade, and watchdog processes clean up legacy desktop runtime interception configurations, so obsolete wrappers or cross-product environment variables no longer affect application startup. QwenWork CN no longer adds the reasoning Token and system-instruction fields that only the legacy interception pipeline provided.

Codex transcript ownership metadata is now cached between polling cycles and refreshed when a file is replaced or truncated, or when the ownership location changes. This reduces disk reads during idle polling while keeping sub-Agent association recoverable.

Disk-usage sampling now staggers its scans, skips the top-level version and runtime directories that Pilot manages, and uses a shorter timeout for each scan. This reduces repeated I/O in large installation directories.

Retired and current Codex trust configurations are now updated atomically from the same config.toml snapshot and verified by reading them back. This prevents duplicate semantic tables from causing partial repair failures and prevents legacy Hooks from being removed before the repair succeeds.

The commercial edition installer now supports Simple Log Service (SLS) API key authentication. You can use --sls-api-key or -SlsApiKey instead of AccessKey credentials to configure SLS, and the installer shows the actual authentication mode before it overwrites an existing configuration.

Qoder IDE can now collect prompts that contain only images and no text. When the official transcript has no user message, Pilot adds a request event that contains only image URIs, so the images enter the subsequent upload and Trace pipelines. Existing text-and-image scenarios are unchanged.

Codex Hook deployment now correctly recognizes quoted trust-configuration tables, preserves valid configurations and explicitly disabled states, and repairs the duplicate entries that Pilot itself created. It refuses to overwrite the original file when the TOML is ambiguous or invalid.

The installer rejects missing, blank, or conflicting SLS credentials. Configuration updates are now written atomically and restricted to read-and-write permissions for the current user only, which prevents partially written files and overly broad credential permissions.

Added lightweight runtime metrics for the Trace buffer, so you can observe the backlog in the pending, processing, and output stages. These metrics do not collect message content.

OpenClaw now supports version 2026.3.8. It identifies the host version, stays compatible with legacy Gateway Hooks, and validates bindings to prevent configuration injection into the wrong host.

Qoder now consistently uses qoder-trace to collect Hooks, session fragments, and Token usage, preventing duplicate or out-of-order data from multiple collection pipelines. When you explicitly disable this input, Qoder no longer falls back to the legacy collector.

Qoder CN CLI now reports the actual model-call duration and Token usage, and improves automatic runtime Hook installation, self-healing, and recovery of incomplete records.

Claude Code and Cursor now include the assistant and tool history from before skill calls, making the reconstructed conversation context more complete.

The commercial edition installer can automatically discover and save the actual OpenClaw entry point, restore the binding when the path changes or the entry point becomes invalid, and preserve your existing configuration and explicit enablement choices.

Claude Code now supplies request times in the fallback parsing path, preventing call records from missing timestamps or reusing incorrect ones.

Qoder IDE now divides steps based on the transcript structure, ignores third-party progress Hooks, and uses nanosecond ordering to keep the relationship between response, tool-result, and request times stable.

Service restart failures now retain diagnostic information and wait for the actual process to recover, so a failed Collector or Updater restart no longer fails silently.

Qoder now retains the final response when tool results are missing, preventing valid replies from being discarded.

OpenCode now generates an independent Turn identifier for a new process after recovery, preventing events from different processes from being merged incorrectly.

OpenClaw can automatically discover and save the actual installation entry point, restore the binding when the path changes or the entry point becomes invalid, and preserve native session-routing information.

Updated the Claude Code, OpenClaw, Codex, and Qoder CLI runtime packages bundled with the commercial edition. The update includes authentication recovery, stable command paths, and shared Core logs.

Installation now lets you specify a local Dashboard port, so you can avoid ports that existing services already use.

Hermes now collects tool definitions and system instructions from model requests to add request context. Content collection remains subject to the existing switches and size limits.

OpenClaw and Hermes now retain message sender identities, making it easier to distinguish requests from different channels and participants.

Local metrics, alerts, updater events, and OTLP failure logs are now written to daily files and cleaned up based on retention-day and soft-capacity targets. This reduces the accumulation of old logs during long-running operation.

Simple Log Service (SLS) delivery failures now include limited network error diagnostics to help you locate connection issues. Existing retry behavior is unchanged.

Standardized the README introduction and usage guidance, making installation, configuration, and related documentation easier to find.

Fixed an issue where OpenClaw session start and end events formed call chains without actual request content, and prevented duplicate collection of input messages during model parsing.

Fixed Qoder model-call fragment pairing by associating start and end events through request identifiers, so model-call durations reflect the actual execution time.

Strengthened collection-process recovery during automatic updates to cover more process-exit and recovery edge cases.

Fixed unpacking failures on Windows caused by short-file-name expansion of temporary directories under paths that contain Chinese characters. The temporary path passed to tar now remains ASCII.

The Windows installer now disables scheduled tasks before it stops them, preventing the previous process from being restarted automatically during installation.

Qoder IDE and Qoder CLI now collect multi-modal content, such as images. They can asynchronously upload local media and write structured URIs to events. If a file is missing, exceeds a limit, or fails to upload, the original text event is retained. The commercial edition supports both API key authentication and pre-signed uploads. Multi-modal storage is now configured through multimodal.storage; migrate environments that use the previous configuration before upgrading.

Every other event that carries input now also generates a contiguous compatible agent.input event. This lets you consume data consistently at Agent input boundaries while retaining the original event and Trace structure.

macOS now provides independent menu bar commands to start and stop collection, plus an optional Dashboard web shortcut. These actions do not stop the collection process or automatically change the Dock during a standard installation or upgrade.

pilot_pipeline now reports metrics for input source reads, parsing, backlog, and duration, and periodically measures the size of the Pilot data directory. A local disk-usage alert is generated when the directory exceeds 5 GiB continuously or exceeds 10 GiB in a single measurement.

Hermes Agent and OpenClaw can read AGENTTEAMS_WORKER_NAME and write valid Worker names to the Agent name and Trace resource attributes, making it easier to distinguish Workers in AgentTeams.

Updated the commercial edition's bundled Claude Code, Codex, Qoder CLI, and OpenClaw AgentTeams Worker Runtime Bundles, together with the Runtime Template. This improves Trace Hook injection, Worker name reporting, and observability environment propagation for locally managed deployments.

Improved upgrade and overwrite-installation reliability. If a slow restart fails, collection is recovered and waits for a healthy heartbeat from the new version. Installation pauses the updater, and Windows installations can correctly unpack, move, and clean up files when %TEMP% uses an 8.3 short path or the account path contains Chinese characters.

Windows overwrite installations now disable scheduled tasks before stopping the service. This prevents Task Scheduler from treating the intentional stop as a failure and restarting the previous process during deployment.

Qoder call-level custom Span attributes are no longer lost during normalization. Retained valid string attributes can continue to be written to Traces by the existing prefix rules.

Fixed request-response pairing, step identifiers, parallel tool history, retry segmentation, and control-line detection for Qoder CLI and QoderWork. This prevents detached zero-duration LLM Spans, empty Traces, duplicate inputs, and incorrect step timing.

The top-level version in Simple Log Service (SLS) output now always identifies the current Pilot version. Runtime versions for the QoderWork family remain in Agent-specific fields, preventing ambiguity about version meaning.

Added observability support for Grok Build. It combines session, update, and execution timing data to produce complete Traces and covers installation, uninstallation, privacy controls, and runtime asset self-healing.

Added K8s init images and injection support. You can integrate through either a manual init container or a webhook, with shared-volume runtime support, graceful shutdown, native dependency checks, and deployment examples.

Claude Code can create local tracing context when upstream Trace Context is unavailable and pass resource attributes to downstream Bash tools, so that cross-process calls can be connected. This feature is disabled by default and can be explicitly enabled through configuration.

Status telemetry is consolidated into the pilot_status and pilot_pipeline data types. These provide stable instance identity and runtime identifier plus traffic metrics grouped by Agent and output destination. The former pilot_input_detail, pilot_flusher_detail, pilot_alarm_metric, and pilot_updater_event data types are no longer reported; migrate queries and dashboards that depend on them to the new structure.

Hardened the core runtime for containerized and multi-user environments. Hooks can be injected before an Agent starts, and native dependency issues, data-directory permission issues, and SLS output configuration errors now provide clear diagnostics with unified data-directory resolution rules.

LLM requests from Cursor on Windows, DeepSeek Harness (DSH), and Pi Coding Agent now emit incremental input messages while retaining complete message snapshots. This improves reconstruction of multi-step ReAct context and maintains consistent content-collection switch behavior.

Fixed token interception and runtime loading for QwenWorkCN on Windows. Installation, upgrade, self-healing, and uninstallation cleanup now also work correctly when QwenWorkCN and QoderWork coexist, preventing environment-variable interference and leftovers.

Updated the four locally managed AgentTeams Worker Runtime Bundles for Claude Code, OpenClaw, Codex, and Qoder CLI. The update includes managed-model protocol fixes for Claude streaming conversion, abnormal truncation detection, in-stream error handling, and Codex Responses protocol hardening.

Fixed installation failures in non-ASCII Windows user directories. Hooks, skills, and plugins are now deployed correctly. A postinstall failure is no longer treated as a successful installation, preventing a normal status from masking missing resources during collection.

Fixed uninstallation from stopping midway when Node cannot be resolved. -Uninstall -Purge now continues and lists skipped steps. When the data directory is retained, the message clearly warns that credentials may remain readable. If a task is owned by Administrators because of an elevated installation, the actual cause and remediation are provided.

Fixed Hook payloads being encoded through the system ANSI code page by some hosts, including Cursor and Qoder, on Windows. Both CP936 and CP1252 cases are recovered, and one corrupted byte no longer causes an entire payload to be discarded.

Fixed installations, restarts, and stops on shared Windows computers from terminating collector or updater daemon processes that belong to other accounts. Process cleanup is now limited to the current installation directory, PID files taken over by new processes are not removed, and installation no longer triggers SERVICE_NOT_RUNNING false positives.

Fixed runtime identification during DSH installation detection, so detection no longer fails when the runtime directory cannot be determined.

Fixed DSH cleanup from recreating the home directory. Cleanup no longer leaves unnecessary directories behind.

Complete conversations with reliable gen_ai.turn.id values now receive compatible turn-start and turn-end markers automatically. Agent-provided original markers are retained, making complete turns easier to analyze consistently.

Workspace and Git context is now standardized across Agents. Codex, Cursor, Qoder, QwenWork CN, and MiMo Code can reliably report the working directory, repository, branch, and domain.

Clarified Token aggregation in the Trace documentation. An LLM Span represents one model invocation and an AGENT Span represents the entire turn, preventing duplicate aggregation in backends such as Langfuse.

Fixed DSH discovery, repair, and uninstallation for nonstandard installation directories. The actual runtime directory can now be safely resolved from Pilot configuration or processes that run under the same user.

Fixed lost Trace association when an upstream TRACEPARENT and a call-level gen_ai.session.id are used together. Final events retain the customer session identity and the correct parent Trace.

Fixed duplicate Codex Token snapshots that could duplicate usage or end a response wave too early. Incremental scans and restarts now retain the correct timing boundaries.

Fixed cases where concurrent input sources could overwrite a newer checkpoint. Checkpoint saves now use serialization and support subsequent retries after failures.

Added call-level GenAI identity overrides. OpenCode, Claude Code, Qoder/Qoder-CN, and OpenClaw can use LOONGSUITE_PILOT_SPAN_ATTRIBUTES to set gen_ai.session.id and gen_ai.user.id. These values are applied consistently to JSONL, SLS, and Trace output.

Updated the local AgentTeams runtime so running Workers can receive MCP service additions and removals promptly. It also tolerates naming conflicts between Agent Package Skills and built-in Skills, preventing stale configuration and Worker startup failures.

Fixed silent extraction failures for precompiled node_modules on Windows when the GNU tar included with Git for Windows interpreted path colons as host:path syntax. Installation now consistently uses Expand-PilotTarGz, prioritizes System32 bsdtar, adds --force-local when required, and includes Sysnative fallback and failure logs.

Fixed an issue in which postinstall.js used an incorrect relative path during installations that use precompiled node_modules, preventing Hook, plugin, and skill assets from being copied to ~/.loongsuite-pilot/.

Added the loongsuite-pilot deploy synchronous deployment command. It can deploy Hooks and plugins in the foreground for non-daemon scenarios such as container image builds. The --require option fails the build when the target Agent is not detected instead of silently skipping deployment.

Added the --mode container container build mode, which skips daemon registration and automatic updates. Use --agents together with loongsuite-pilot deploy --require to ensure deployment is complete in the build layer. container-entrypoint.sh is provided as a PID 1 entry point to handle signals and refresh the collector.

Qwen Code CLI now correctly propagates call-level Span attributes to Trace output, improving Tracing Analysis completeness.

Updated the local Worker AgentTeams Runtime Bundles for Claude Code and OpenClaw to 0.0.12, and for Codex and Qoder CLI to 0.0.8. The update includes a POSIX process-tree termination fix.

When automatic updates are disabled, health probes no longer report false positives for a missing updater process, reducing unnecessary alert noise.

Fixed a condition where a changed command line name for the lock-holder process could create duplicate collectors. Lock recovery now also handles PID reuse correctly.

Fixed duplicated ancestor conversation history when Codex sub-Agents fork. The new logic skips copied regions during the first scan and detects very large copied prefixes across scan cycles.

Fixed injected context in DSH collection being incorrectly counted as root input.

Fixed assistant tool-call history being lost during cross-Agent calls involving Qoder, Cursor, Qwen, and WorkBuddy, preserving complete LLM input history.

Fixed incorrect Token-usage field mapping in DSH collection.

Added support for cross-building precompiled node_modules for all five platforms from one darwin-arm64 machine: darwin-arm64, darwin-x64, linux-x64, linux-arm64, and win-x64. Each native module's target architecture is validated with file(1) before packaging.

When the npm install fallback path fails, complete error output and debug logs are now printed. This avoids leaving only an unhelpful log-path reference in container build layers or continuous integration, and adds a retry policy for registry retrieval.

Added DeepSeek Harness (DSH) observability integration, with support for the Cordis plugin, incremental session collection, time to first token (TTFT) reporting, event conversion, and reversible YAML deployment.

Added PI SDK Agent observability support, covering data collection for agents built on the software development kit (SDK) and registration recovery.

The dashboard now provides a local metrics summary view, with a bilingual interface, a language selector, token usage visualization, and local port configuration.

Added a multi-modal collection framework that supports Codex image content collection, file extraction, and fine-grained multi-modal control.

Fixed an issue where the token usage command-line interface (CLI) was not exposed on Windows.

Fixed DSH telemetry recovery and plugin lifecycle management issues, isolating failed trace conversions while preserving actual tool definitions.

The installer now applies the DSH uninstallation cleanup logic, so that the YAML patch is correctly reverted during uninstallation.

Added standalone collection support for QwenWorkCN, which collects session, trace, and token usage data and supports custom data directories.

Codex collection can now correlate and merge completed first-level sub-agent executions, filling in delegated inputs and execution results while preserving the parent-child identity.

Simple Log Service (SLS) output now supports configurable request timeouts, exponential backoff retry with jitter, and a concurrency limit, reducing delivery failures caused by network fluctuations and retry bursts.

OpenCode now deploys its plugin automatically on first installation, and a unified serviceName lets you pin the service name for different agents.

Installed AgentShell instances can update their Simple Log Service and Cloud Monitor reporting configurations in place, with automatic rollback on failure, so no re-download or version switch is required.

Updated the built-in AgentTeams local worker runtime so it can inherit local skills and native MCP resources on demand, while the default isolation behavior stays unchanged.

Claude input messages now retain the complete tool calling history, improving the continuity of contextual trace data.

The Windows hook and command-line interface (CLI) wrapper are compatible with Constrained Language Mode (CLM) and consistently process JSON data as UTF-8, improving reliability on managed endpoints.

The OpenClaw compatibility check no longer invokes the CLI directly, and version detection, recovery, and cleanup of legacy configurations are enhanced.

The Windows commercial installer now runs in WDAC/CLM environments and verifies configuration writes by reading them back, preventing interrupted installations and false successes.

Uninstallation now also removes the OpenClaw plugin and its legacy configurations, reducing leftover files and conflicts during later reinstallation.

Corrected the npm package repository URL and completed the package metadata, making it easier to reach the source code and issue feedback entries from the npm page.

Added OpenClaw Agent support. After installation, Pilot can collect AI coding activity data from OpenClaw.

The installation process now supports downloading a managed Node.js runtime and precompiled node_modules, reducing installation failures caused by differences in the user's local Node.js environment.

The automatic upgrade process now uses a managed Node.js runtime and prebuilt dependency packages, improving upgrade stability and reducing local compilation dependencies.

Support for custom agent names and instance IDs across agents, making it easier to distinguish data sources in multi-instance or custom deployment scenarios.

Added turn start and end event markers for Qoder CN IDE, improving session boundary recognition.

Fixed Shell hook parsing issues in sh environments and enabled npm commands to run through the managed runtime, improving compatibility across different shell environments.

When the managed Node.js runtime pinning fails, automatic upgrades now abort activation and roll back, preventing the client from entering an incomplete dependency state.

Optimized the tiering and debounce logic for Pilot process CPU and memory alerts, reducing duplicate alerts while preserving critical resource risk signals.

Fixed an issue where UTF-8 BOM in Windows PowerShell input caused configuration writes and agent detection to fail silently. Installation results are now properly validated.

Fixed an issue on Windows where Node.js could not be resolved during uninstallation, leaving Claude Code and Codex hook configurations behind.

Uninstallation now preferentially reads the Node.js path pinned during installation, preventing cleanup failures for IDE hooks on machines without a system Node.js.

Fixed dependency installation failure handling when the Linux/macOS installer runs npm through the managed runtime. Failures now terminate explicitly, preventing silent incomplete installations.

Added secret leak scanning for pull requests, reducing the risk of sensitive credentials being accidentally committed.

Adjusted the OSS path prefix for Node.js dependencies in the installer to ensure download paths match the release directory structure.

Added native plugin collection support for Hermes Agent. Pilot can now collect Hermes Agent activity data through the native plugin pipeline.

Codex Token periodic sampling now includes comparison fields with the metrics summary, including sample_id, summary token, generation time, data age, and delta, making it easier to locate token statistics discrepancies.

The four built-in AgentTeams Runtime Bundles in the commercial package are updated to support Windows native managed Workers, covering PowerShell entry points, command parsing, and process lifecycle management.

Codex Token scanning now includes a 200 MiB circuit breaker. When oversized logs are encountered, scanning is skipped while retaining the traceable sample_id, avoiding sampling cost amplification.

The daemon lock file is moved to the dataDir root directory, at the same level as the pid file, for a cleaner runtime state path.

The alert inspection workflow now explicitly requires tracing from alert thresholds to the monitored business or collection code, reducing cases where threshold adjustment is misidentified as the root cause.

The shutdown process now performs synchronous flush and logs errors even when the Orchestrator stop fails, reducing the risk of losing shutdown logs during hard exits.

Fixed an orphan process issue caused by the pino-roll rotation timer in the Windows daemon. Node now manages pid file creation and cleanup, improving exit and recovery reliability.

Removed .NET static calls for CLM/WDAC disabling from the Windows installer. Installation, uninstallation, and scheduled task cleanup are now more stable in restricted PowerShell environments.

The Windows Updater sync script now writes to loongsuite-pilot-service.ps1 and cleans up old scripts, preventing automatic upgrades from re-shadowing the .cmd command entry point.

Fixed CLM/WDAC, GBK misrepair, duplicate collection, and uninstallation residue issues in the Windows installer, hook wrapper, and single-instance lock, improving Windows collection stability.

Qoder CN Token supplementation now probes multiple SQLite candidate paths for desktop and IDE plugins, reducing cases where llm.response is missing usage, response.id, and request.id.

Qoder Trace Step assembly is now more stable and limits the amplification risk of retrying transcript reads, reducing step ordering and collection stability issues.

The status bar now aggregates daily metrics incrementally, reducing duplicate calculation risk and improving current-day display accuracy.

Added WorkBuddy transcript collection and quality gates, improving WorkBuddy session data coverage and publish verification capability.

Added MiMo Code Agent log collection, expanding the range of AI Coding tools observable by Pilot.

Added Simple Log Service (SLS) API key authentication support and fixed related time handling issues, making it easier to configure data reporting in more environments.

Added PII desensitization detection for ID cards, phone numbers, emails, IP addresses, and bank card numbers, with enhanced overlap hit and digit scan handling.

Added native Windows local Worker support and tightened Worker lifecycle and process scope, improving installation and runtime reliability in Windows environments.

Added Pi Coding Agent observability support. Users can reuse Pilot's local collection and output pipeline in Pi Coding Agent scenarios.

Added local log file-based token usage collection, improving the completeness of local session usage statistics.

Updated the AgentTeams local Worker Runtime Bundle. Claude Code, OpenClaw, Codex, and Qoder CLI templates will use the new Worker package.

Enhanced Codex Hook compatibility on Windows and added install, cleanup, and health check logic to reduce the failure rate when enabling collection for Windows users.

Added Windows Agent support matrix documentation to help users determine the support status of different Agents on Windows.

Fixed Qoder token usage value priority to reduce cases where token usage is overwritten by lower-priority data during multi-source statistics.

Fixed session discovery with custom CODEX_HOME in Codex to ensure sessions can still be collected after users modify the Codex data directory.

Added support for sending traces to multiple backends simultaneously, enabling parallel integration with both platform-managed observability and your own observability system.

Added upstream trace correlation and call-level span attribute propagation. External orchestration systems can now trace an agent call chain more completely.

Fixed an issue where service installation in the root environment still required sudo. Installation and uninstallation in containers and root user scenarios are now more stable.

Fixed an issue where QoderWork applications might load an incorrect worker runtime, preventing cross-application runtime mixing that could cause collection anomalies.

Fixed several collection stability issues in Codex, QoderWork CN, and hook log, reducing data loss in turn recovery, trace-quality, and date-switching scenarios.

Added git.* and custom attribute injection for trace spans, with a new span-attr command for adding observability dimensions by project or environment.

Added local output log cleanup to reduce disk pressure from long-term log accumulation.

Improved workspace attribution for OpenCode sessions. Traces and event records can now more accurately associate with the repository, branch, and current workspace.

Restructured deployment diagnostics and documentation indexes, adding troubleshooting material for Qoder JetBrains and dependency injection.

Fixed inconsistent tool parameter, result, and error state mapping in Wukong activity snapshots. Structured tool data is now more complete.

Fixed an issue where the updater self-healing path prematurely marked a restart as successful. When registration fails or the process does not start, the system now continues to the fallback recovery logic.

Removed the deprecated --system-service path from the installer and aligned with the new init system detection logic, reducing installation and restart failure probability.

Changed Linux init system detection to automatic cascade and removed the nohup fallback launch logic, preventing inconsistent runtime state detection after service registration failure.

Fixed packaging script invocation in the open-source release workflow, preventing missing release packages or script path errors.

Added Kiro CLI collection support. LoongSuite Pilot can now collect session data from shell hooks, SQLite transcripts, and session JSONL sources. This enables deferred collection, deduplication, and timing recovery for interactive sessions. With Kiro CLI collection enabled, you can observe model calls and tool call chains more completely.

Refactored the file collection capability into a general-purpose pipeline subsystem and added the qoder-api pipeline. This update supports multi-pipeline lifecycle management, Qoder API sliding-window collection, failure log persistence, and backward compatibility with legacy configurations. The pipeline subsystem makes it easier to add new collection channels in the future.

Added the alarm-triage capability for alert diagnosis. This feature analyzes root causes in parallel based on anomaly snapshots in Simple Log Service (SLS) and generates structured issue records. Alarm-triage helps you move from manual investigation to reproducible fix recommendations.

Updated LoongSuite repository links in the README and Chinese README, and refined the Java project description. These changes reduce the likelihood of navigating to the wrong project or misunderstanding component responsibilities.

Refreshed the AgentTeams local runtime resource bundle to keep the local runtime package aligned with the latest AgentTeams capabilities.

Fixed an issue where historical turns in Codex fork transcripts were collected repeatedly. This fix reduces duplicate spans and duplicate session data in fork scenarios.

Fixed an issue where the alarm-triage feature did not explicitly specify the cn-shanghai region when calling Alibaba Cloud CLI. This fix prevents alert snapshot query failures caused by inconsistent default profile regions.

Fixed issues related to AgentTeams worker runtime bundles to ensure that managed workers use the updated runtime resources.