smartcomputer-ai/lightspeed

Lightspeed is a durable, scalable agent harness that orchestrates AI agent sessions using a deterministic, event-sourced core built on Temporal workflows. It provides a complete runtime environment for managing agent lifecycles, tool execution, and multi-tenant isolation through a structured API and CLI. The system supports complex agent behaviors including virtual file systems, remote MCP server integration, and web access, all managed via a robust storage and authentication substrate.

Users can now interact with the Anthropic Messages API through a new client implementation. The change introduces a native client in \crates/llm-clients/src/anthropic\ that supports API key authentication, OAuth bearer token authentication, and configurable beta headers. The client handles request headers, URL construction, and error mapping for the Anthropic API.

crates/llm-clients/src/anthropic · high confidence

The system now includes new tooling for fetching public web pages and performing web searches. The \web\_fetch\ tool retrieves public HTTP/HTTPS URLs with strict security guards that block private, loopback, and non-public network destinations, and extracts clean text from HTML or JSON responses. The \web\_search\ tool supports cached or live search modes with configurable context size, domain allow/block lists, and optional user location data. Both tools are gated by configuration flags (\enabled\ for fetch, \mode\ for search) and return structured results including content, status codes, and truncation status.

crates/tools/src/web · high confidence

Users can now interact with OpenAI's API through a new client implementation in the \llm-clients\ crate. This adds support for three distinct API endpoints: Chat Completions (text generation), Audio Transcription (converting audio to text), and the Responses API (including model listing). The implementation includes a shared HTTP transport layer with configurable timeouts, organization/project header injection, and SSE streaming support. Configuration is handled via environment variables (\OPENAI\_API\_KEY\, \OPENAI\_BASE\_URL\, etc.) and allows for per-request authentication overrides.

crates/llm-clients/src/openai · high confidence

Introduced a new local development environment for Lightspeed, providing a complete set of shell scripts and a Docker Compose configuration to run Postgres, pgAdmin, MinIO, and Temporal locally. The \local/\ directory now includes \common.sh\ for shared variables, \env.sh\ to export environment variables, and helper scripts (\up.sh\, \down.sh\, \reset.sh\, etc.) to manage the local infrastructure, enabling developers to run and test the application against local service instances.

local · high confidence

Introduced new modules in the engine's session layer to support durable session logging. This includes a \StoredEvent\ struct for serializing and deserializing event payloads, along with supporting types for session positions, log entries, and string/numeric IDs with validation rules. These changes provide the foundational data structures for tracking and storing session events.

crates/engine/src/session · high confidence

Added a new \FleetToolsetConfig\ and associated tool definitions for managing subagents, including \agent\_spawn\, \agent\_request\, \agent\_send\, \agent\_list\, and \agent\_read\. The module defines data structures for agent lifecycle, environment policies, and VFS isolation, enabling the system to spawn, communicate with, and monitor background agent sessions.

crates/tools/src/fleet · high confidence

The gateway module now exposes a new HTTP/JSON-RPC server (http.rs) that routes requests to specific Temporal universes based on the configured authentication mode (single, trusted-header, or API key). It introduces an operator API (operator.rs) for deployment-level management of universes (create, list, read, delete) and handles session termination and blob cleanup during universe deletion. The principal resolution (principal.rs) propagates caller identity through request-scoped task locals, enabling audit trails and per-universe isolation.

crates/temporal-server/src/gateway · high confidence

The \llm-clients\ crate now exposes a structured error hierarchy (\LlmApiError\) covering configuration, transport, decoding, streaming, and provider-specific HTTP failures, enabling more precise error handling for API clients. Additionally, a \RequestAuth\ enum is introduced to abstract per-request authentication, supporting both provider-native API keys and OAuth bearer tokens.

crates/llm-clients/src · high confidence

Users can now use the new Lightspeed CLI to manage sessions, configure authentication (including OAuth and model provider credentials), manage environment bindings, control session skills, link remote MCP servers, and upload or materialize VFS snapshots. The CLI exposes subcommands for profiles, auth grants, environment activation, and workspace management, all communicating with the Lightspeed API gateway.

crates/cli/src · high confidence

A new Streamable HTTP MCP server is added to the \configurator-mcp\ directory, exposing a configurable subset of the universe-scoped Lightspeed JSON-RPC contract. The server generates 64 tools from the canonical method manifest, excluding operator methods and specific environment/job endpoints defined in \tool-filter.json\. It supports three authentication modes—single, trusted-header, and api-key—and enforces host and origin restrictions. The tool surface is generated via a build script that reads from \../contract\ and produces TypeScript descriptors, with tests verifying the tool count, schema structure, and authentication behavior.

interop/configurator-mcp · high confidence

Added the \temporal-server/src/worker\ module to manage long-running Temporal worker processes and activities. This includes a \PromiseReaper\ background task that scans sessions to repair broken promises and cancel stale workflows, and a \BrokerSecretResolver\ that resolves model provider credentials and MCP server tokens via the auth broker. The module also exposes \FakeLlm\ and \FakeTools\ implementations for testing, alongside activity definitions for environment job management, tool invocation, and audio preprocessing.

crates/temporal-server/src/worker · high confidence

Added a new \temporal-workflow\ crate that implements the deterministic session orchestration layer using Temporal workflows and activities. This includes the \WorkflowActivities\ struct defining operations such as \create\_or\_load\_session\, \tool\_invoke\_batch\, and \environment\_job\_start\, alongside configuration defaults and type definitions for agent sessions, admissions, and run summaries. The module also provides helpers for connecting to Temporal and reducing session logs for efficient state reconstruction.

crates/temporal-workflow/src · high confidence

The \crates/vfs\ crate now provides the core data structures and validation logic for a content-addressable virtual filesystem. This includes \VfsPath\ for normalizing and validating file paths, \VfsSnapshotManifest\ for serializing directory trees and file metadata, and \VfsWorkspaceRecord\ for tracking workspace heads and revisions. These models enable the system to manage immutable snapshot references and workspace links, allowing users to create, read, and validate VFS snapshots and workspace states.

crates/vfs · high confidence

Added a new skill catalog system that discovers, parses, and builds a unified catalog of skills from VFS workspace links. This includes model definitions for skill metadata, a parser for skill frontmatter, and a builder that aggregates these into a serialized catalog snapshot. The system supports scanning multiple root directories, handling workspace links, and publishing the resulting catalog to the core agent state.

crates/tools/src/skills · high confidence

The \crates/auth\ crate now provides a complete, provider-independent authentication substrate. It introduces a token broker that resolves bearer tokens for grants, enforcing status, expiry, and audience scopes. The crate adds an OAuth authorization-code flow service that manages PKCE, state, and callback handling. It also includes drivers for MCP OAuth (automatic client discovery and registration) and GitHub App authentication (JWT signing and installation token minting). Additionally, it supports static bearer tokens and custom OAuth providers. All secret values are encrypted at rest, and the broker ensures single-flight token renewal to prevent race conditions.

crates/auth · high confidence

A new \api-projection\ crate has been added to serve as the explicit bridge between the internal reducer/CoreAgent state and the stable client-facing API. This component is responsible for projecting committed logs and session state into \SessionView\, \RunView\, and \ContextView\ structures, handling the translation of internal types like \CoreAgentEntry\ and \RunStatus\ into their corresponding API representations.

crates/api-projection · high confidence

The engine crate now defines the foundational domain types for the system's internal messaging and storage. This includes BlobRef for content-addressed blob references, EmissionId and EmissionBody for deterministic, cross-workflow event emissions, and the StoredEvent type for session logs. These changes establish the closed vocabulary and deterministic planning structures that underpin the durable workflow plugin infrastructure.

crates/engine/src · high confidence

The \store-fs\ crate now provides concrete filesystem implementations for core storage interfaces. \FsBlobStore\ persists binary blobs as files under a \.lightspeed/cas\ directory, using SHA-256 hashes for content-addressed storage. \FsSessionStore\ manages session state by writing a \session.json\ index and an append-only \events.jsonl\ log per session directory. \FsVfsCatalogStore\ persists VFS snapshot and workspace metadata as JSON files under \.lightspeed/vfs\. Together, these components replace in-memory or external storage backends with durable, project-scoped filesystem layouts.

crates/store-fs · high confidence

The host-bridge component is introduced as a new runtime that manages local processes, background jobs, and filesystem interactions. It exposes a WebSocket-based RPC interface for starting and monitoring processes, managing job lifecycles (including restart-safe state and secret injection), and performing read/write operations on the host filesystem. The bridge registers with a central gateway, sends periodic heartbeats, and exposes capabilities for process execution, job management, and file system access.

crates/host-bridge/src · high confidence

The CLI now features a redesigned chat command with a new driver, protocol, and session management. Users can start or resume chat sessions, configure model providers, set reasoning effort, and control features like web search, web fetch, and filesystem tools. The interface supports both interactive TUI and headless JSON output, and allows mounting local directories as VFS workspaces for chat context.

crates/cli/src/chat · medium confidence

Added new modules in crates/tools/src/prompts to handle prompt instruction discovery, assembly, and VFS-based root resolution. The assembler module provides builders and functions to scan, sort, and assemble prompt instructions from multiple roots, producing a structured report and context entries. The VFS module resolves linked VFS prompt roots from workspace links, supporting both conventional paths (.lightspeed/prompts, .agents/prompts) and configured custom roots, while handling workspace link availability and filesystem errors. The model module defines the data structures for prompt instructions, sources, fingerprints, and warnings, enabling consistent serialization and validation of prompt metadata.

crates/tools/src/prompts · high confidence

Added new storage interfaces for managing session state and content-addressed blobs. The \session.rs\ file defines the \SessionStore\ trait and related types (e.g., \SessionRecord\, \CreateForkedSession\) to handle session lifecycle, event appending, and session linking. The \blobs.rs\ file introduces the \BlobStore\ and \BlobGraphStore\ traits to manage binary data and their relationships. These contracts allow the engine to persist and retrieve session data and associated blobs, supporting features like session forking and structured concurrency.

crates/engine/src/storage · high confidence

The tools crate now supports structured concurrency and durable environment jobs. Users can submit, run, and read status of long-running or asynchronous jobs via new \env.job\_submit\, \env.job\_run\, and \env.job\_read\ tools. Additionally, the system introduces \await\, \cancel\, and \detach\ tools to manage concurrent execution and process lifecycles, enabling more complex, multi-step agent workflows.

crates/tools/src · high confidence

The eval crate now uses a new, structured JSON format for evaluation cases, defining fields for setup, expectations, and run parameters. The harness loads these cases, validates provider support (OpenAI, Anthropic), and executes runs with configurable limits on tokens, turns, and tool rounds. This change introduces a more robust and extensible way to define and run agent evaluations.

crates/eval/src · high confidence

The \crates/engine/src/core\ module now contains the complete Lightspeed CoreAgent domain, implementing a closed finite state machine that manages session lifecycle, run planning, tool invocation, and context compaction. This includes new modules for command admission (\admit.rs\), event application/reduction (\apply.rs\), serialization (\codec.rs\), the substrate-neutral drive machine (\drive.rs\), I/O traits (\io.rs\), and deterministic planning (\planning.rs\). The drive machine coordinates state transitions and emits actions for LLM generation, tool batches, and context compaction, while the codec handles storage of session events. This provides the core engine logic for managing agent sessions and their internal state.

crates/engine/src/core · high confidence

A new private TypeScript client, LightspeedClient, is provided in the interop/ts-client package to interact with the Lightspeed JSON-RPC gateway. The package includes a generated type system and method map derived from the contract schema, along with a build script (generate.mjs) that compiles the JSON schema into TypeScript types and a method registry. The client supports typed JSON-RPC calls, handles session and run lifecycle methods (such as startRun, readEvents, and awaitRun), and provides structured error handling via LightspeedRpcError and LightspeedTransportError. An example demonstrates integration with Temporal activities, and tests verify the client's behavior.

interop/ts-client · high confidence

The crates/profiles module now provides the runtime registry and validation layer for agent profiles. It defines the ProfileStore trait for creating, reading, updating (with optimistic locking via revision numbers), listing, and deleting profiles, alongside helper traits to validate profile documents, inline profiles, and instructions. This establishes the core data model and error handling for profile management.

crates/profiles · high confidence

The \crates/api\ crate now defines the full JSON-RPC wire contract for the Lightspeed agent API. This includes the \auth\ module for managing OAuth clients, auth grants, and provider configurations; the \environments\ module for creating and managing execution environments and their credentials; and the \mcp\ module for registering and managing remote MCP servers. Additionally, the \operator\ module exposes deployment-level methods for managing universes and API keys, while \profiles\ defines the structure for agent profiles. The \constants\ module establishes the protocol version and all JSON-RPC method names, and the \handshake\ module defines the initialization and capability negotiation flow.

crates/api · high confidence

The \llm-runtime\ crate introduces a new adapter layer that translates the engine's provider-neutral LLM requests into native API calls for OpenAI (Responses API) and Anthropic (Messages API). This includes dedicated adapters for generation and context compaction, a registry for routing requests to the correct provider implementation, and supporting modules for handling provider-specific parameters, secret resolution, and blob storage. This change enables the system to execute LLM calls against these specific providers while maintaining a clean separation between the deterministic agent core and provider-specific HTTP clients.

crates/llm-runtime/src · high confidence

The CLI now features a new terminal-based chat interface (TUI) that renders chat transcripts, handles user input, and manages the UI loop. The interface supports slash commands for session management, model/provider selection, skill activation, and run control (interrupt/steer). It renders messages, reasoning, tool chains, and errors with distinct cell types and styling. The terminal handles viewport resizing, history insertion, and cursor management.

crates/cli/src/chat/tui · high confidence

The PostgreSQL migration scripts have been completely redesigned to support the new Lightspeed architecture. The changes introduce tables for core session management (including clone/fork lineage), a versioned VFS catalog for workspace heads and snapshots, and a remote MCP server catalog. A new generic auth substrate is added to store encrypted secrets, OAuth clients, and grants, while environment providers and credentials are modeled to support sandbox and bridge environments. Additionally, the schema now includes a catalog for agent profiles and a deployment-scoped table for inbound API key authentication.

crates/store-pg/migrations · high confidence

The gateway service now exposes endpoints for managing environment lifecycles (create, read, list, close) and environment providers (register, heartbeat, unregister, list). It also introduces APIs for binding, listing, and unbinding environment credentials, supporting auth grants, provider credentials, or direct secrets. Additionally, a new auth API handles creating and viewing auth grants, validating MCP server grant compatibility, and mapping authentication errors. Blob storage operations (put, read, has) are also added to the gateway service.

crates/temporal-server/src/gateway/service · high confidence

The environments crate now provides a complete runtime environment registry, including the EnvironmentProviderId and EnvironmentJobGroupId string types, an EnvironmentProviderRecord with lease-based presence tracking, and an in-memory implementation (InMemoryEnvironmentRegistryStore) that supports registering providers, observing environments, binding credentials, and managing provider status and heartbeats. This introduces the foundational data model and persistence layer for environment selection and runtime state handoff.

crates/environments · high confidence

Added new tools for managing and executing jobs and processes within an environment. The \environment\ module now exposes \environment\_list\, \environment\_read\, \environment\_activate\, and \environment\_deactivate\ for environment selection and state management. Additionally, \job\_submit\, \job\_read\, \run\_process\, and \write\_process\_stdin\ tools are introduced to support durable job execution and local process execution, with corresponding argument structures and execution traits defined in the environment tools crate.

crates/tools/src/environment · high confidence

The \crates/tools/src/fs\ module introduces a new filesystem abstraction layer, including a \FileSystem\ trait and implementations for local (\LocalFileSystem\) and in-memory (\InMemoryFileSystem\) storage. This change adds a \FileAccessPolicy\ to enforce read/write and scoping constraints, alongside wrappers for read-only and scoped access. Additionally, it introduces a new \apply\_patch\ tool that parses and applies patch files to the filesystem, supporting add, delete, and update operations with a summary of changes.

crates/tools/src/fs · high confidence

A new \host\_protocol\ module has been introduced, providing a reusable conformance test suite (\assert\_host\_data\_conformance\) that validates transport handshakes, filesystem operations, and capability negotiation. The module also exposes remote adapter structs (\RemoteHostConnection\, \RemoteHostFileSystem\, \RemoteProcessExecutor\) that wrap the \host-client\ to implement the \FileSystem\ and \ProcessExecutor\ traits, enabling providers to easily integrate with the host data plane.

_crates/tools/src/host\protocol · high confidence

The host-client crate now provides a typed client for the host protocol, enabling programmatic interaction with the host's control and data planes. Users can now initialize connections, list and create targets, and attach to them via the controller plane. On the data plane, the SDK supports file system operations (read, write, create directory, copy, remove), process management (start, read, write, terminate, resize), and job lifecycle management (start, list, read, cancel). The client handles JSON-RPC 2.0 serialization, WebSocket transport with optional bearer token and user-agent headers, and asynchronous notification handling.

crates/host-protocol · high confidence

Added a new \InlineToolRuntime\ in \crates/tools/src/runtime\ that provides an in-process execution path for CoreAgent tool calls. The runtime resolves tool bindings from a \ToolCatalog\, dispatches calls to either the virtual file system or the active environment context, and handles JSON argument serialization and output encoding. This introduces a new mechanism for invoking tools locally within the agent's runtime.

crates/tools/src/runtime · high confidence

The chat interface now features a dedicated bottom pane that handles user input, slash commands, and interactive pickers for model, provider, reasoning effort, max tokens, sessions, and skills. Users can type messages, trigger slash commands, and select options from dropdown-style lists directly within the terminal UI.

_crates/cli/src/chat/tui/bottom\pane · high confidence

The PostgreSQL store now includes dedicated modules for managing deployment-scoped API keys, encrypted secret storage, content-addressed blob storage with an in-memory cache, environment provider registries, and MCP server registries. These additions provide the underlying persistence for authentication, credential management, file storage, and service discovery, supporting the broader multi-tenant and environment-based architecture.

crates/store-pg/src · high confidence

A new \crates/test-support\ crate has been added, providing a fast, in-process harness for driving \CoreAgent\ sessions to quiescence. It exposes a \SessionRunner\ that accepts commands, manages session state, and emits entries, with optional tool and VFS workspace store integration. The crate is explicitly not a production runtime and does not implement \api::AgentApiService\. Tests verify serialization/deserialization of drive session protocols.

crates/test-support · high confidence

The \crates/temporal-server/src/worker/activities\ directory has been restructured into a set of new modules (\common\, \compaction\, \environment\_jobs\, \llm\, \preprocess\, \runtime\_projection\, \state\, \storage\, \tools\, \workflow\_tools\) that implement Temporal activities for core agent operations. These include LLM generation and context compaction handlers, audio transcription and transcoding via FFmpeg, environment job submission and polling, and workflow tool execution adapters. The \common\ module provides shared error handling and blob storage utilities, while \state.rs\ defines the dependency injection structures for each activity type. This change introduces the underlying worker-side implementation for these capabilities.

crates/temporal-server/src/worker/activities · high confidence

The \crates/mcp\ crate now introduces a new \McpServerRecord\ struct and associated types (such as \McpServerId\, \PutMcpServerRecord\, and \McpRegistryError\) that define the data model for remote MCP server catalogs. This change establishes the core data structures and validation logic for managing server configurations, including fields for authentication policies, transport types, and approval defaults, effectively replacing the previous implementation with a more structured and validated approach.

crates/mcp · high confidence

The server now manages per-universe runtime state in a lazy, LRU-cached registry that is evicted after 4 hours of idleness. Environment resolution and credential injection have been restructured: the \EnvironmentResolver\ enforces provider allowlists and liveness checks, while \EnvironmentCredentialResolver\ resolves secrets from grants, auth providers, or direct storage and injects them into tool contexts. The \UniverseRuntime\ coordinates shared deployment resources (Postgres, object store, LLM clients) across all universes, and the CLI exposes \server universe\ and \server api-key\ commands for multi-tenant management.

crates/temporal-server/src · medium confidence

The engine's core components have been refactored to introduce a structured session lifecycle (new, open, closed) and a new \SessionConfig\ that groups generation, limits, context, and feature flags. The change introduces explicit commands for managing session configuration, context entries, and environment selection, alongside a new promise-based concurrency model for tool calls and workflow invocations. Users will see a more robust handling of session state, context compaction, and tool execution, with improved error handling and validation for configuration updates.

crates/engine/src/core/components · high confidence

The \AgentSessionWorkflow\ and \EnvironmentJobWorkflow\ have been restructured into a modular, state-driven architecture. The session workflow now delegates core logic to separate modules for admissions, awaits, bootstrap, clock, drive, errors, and observability, while the environment job workflow manages job polling, cancellation, and tool execution. This change introduces a more explicit separation of concerns, with dedicated files handling specific workflow responsibilities such as input preprocessing, tool batch resumption, and history rollover management.

crates/temporal-workflow/src/workflows · medium confidence

The default Rust entry point (src/main.rs) containing the 'Hello, world!' print statement has been removed from the source tree.

src · high confidence

The project has been renamed from 'Forge' to 'Lightspeed', a change reflected in the README header, logo, and all internal references. The README has been significantly expanded to describe the new product vision: a durable, scalable agent harness built on a deterministic, event-sourced core that runs on workflow engines like Temporal. The documentation now details features such as virtual file systems, multi-tenancy, and borrowed compute, alongside updated local development instructions and architecture diagrams. Additionally, a new \.env\_example\ file was added to document required environment variables (e.g., \OPENAI\_API\_KEY\, \ANTHROPIC\_API\_KEY\), and the \.gitignore\ was updated to exclude new local state and configuration files.

(repo-wide) · high confidence

Added integration tests for the host-bridge server; Added live integration tests for Anthropic and OpenAI LLM adapters; Added live integration tests for LLM clients; Added live integration tests for session lifecycle, API keys, and session isolation; Added test support for retrying LLM API clients.

The project's Cargo and npm lockfiles have been updated. Rust dependencies include aes-gcm 0.10.3, jsonwebtoken 9, reqwest 0.12, sqlx 0.8, and temporalio-sdk 0.4.0. JavaScript dependencies include @modelcontextprotocol/sdk 1.29.0, express 5.2.1, and typescript 5.8.3.

(dependencies) · high confidence

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

• CAI 54 → 59 (+4.8)
• Rubric changed (rubric-2026.08.18 → rubric-2026.08.19) — scores are not directly comparable.

• Code Health 69 → 69 (-0.1)
• Architecture 99 → 100 (+0.9)
• Maturity 79 → 79 (-0.0)
• Readiness 25 → 37 (+11.3)
• Security 82 → 78 (-4.1)
• Domain Modelling 99 → 99 (-0.0)
• Event Sourcing 100 → 100 (+0.0)

• Change coupling: admit.rs ↔ codec.rs (crates/engine/src/core/admit.rs)
• Change coupling: api_client.rs ↔ mod.rs (crates/cli/src/api_client.rs)
• Change coupling: lib.rs ↔ drive.rs (crates/api-projection/src/lib.rs)
• Change coupling: runtime_projection.rs ↔ drive.rs (crates/temporal-server/src/worker/activities/runtime_projection.rs)
• Change coupling: schema_export.rs ↔ mod.rs (crates/api/src/schema_export.rs)
• FileTooLong: service/vfs_api.rs (crates/temporal-server/src/gateway/service/vfs_api.rs)
• FileTooLong: src/lib.rs (crates/environments/src/lib.rs)
• FsVfsCatalogStore::remove_workspace_mounts_locked (cognitive 17) (crates/store-fs/src/vfs.rs)
• GatewayAgentApi::ensure_core_environment_job_workflow_tool (cognitive 18) (crates/temporal-server/src/gateway/service/mod.rs)
• GatewayAgentApi::wait_for_environment_default_target (cognitive 17) (crates/temporal-server/src/gateway/service/environments.rs)
• GatewayAgentApi::wait_for_session_toolset (cognitive 21) (crates/temporal-server/src/gateway/service/vfs_api.rs)
• High CVE: [GHSA redacted] (interop/configurator-mcp/package-lock.json)
• Hotspot: crates/engine/src/core/components/context.rs (crates/engine/src/core/components/context.rs)
• Hotspot: crates/llm-runtime/src/openai_responses.rs (crates/llm-runtime/src/openai_responses.rs)
• LLM evaluation failed
• context::validate_external_context_edit_entry (cognitive 19) (crates/engine/src/core/components/context.rs)
• context::validate_external_context_edit_entry (cyclomatic 20) (crates/engine/src/core/components/context.rs)
• service::existing_admitted_run_submission (cognitive 16) (crates/temporal-server/src/gateway/service/mod.rs)
• service::existing_message_submission (cognitive 16) (crates/temporal-server/src/gateway/service/mod.rs)

• FileTooLong: components/config.rs (crates/engine/src/core/components/config.rs)
• FileTooLong: src/mcp.rs (crates/store-pg/src/mcp.rs)
• GatewayAgentApi::ensure_core_environment_job_workflow_tools (cognitive 21) (crates/temporal-server/src/gateway/service/mod.rs)
• GatewayAgentApi::wait_for_active_environment (cognitive 17) (crates/temporal-server/src/gateway/service/environments.rs)
• GatewayAgentApi::wait_for_session_toolset (cognitive 17) (crates/temporal-server/src/gateway/service/session_toolset.rs)
• High CVE: [GHSA redacted] (interop/configurator-mcp/package-lock.json)
• High CVE: [GHSA redacted] (interop/configurator-mcp/package-lock.json)
• High vulnerability: [GHSA redacted] (interop/ts-client/package-lock.json)
• Hotspot: crates/engine/src/core/components/tooling.rs (crates/engine/src/core/components/tooling.rs)
• Hotspot: crates/eval/src/main.rs (crates/eval/src/main.rs)
• Medium CVE: [GHSA redacted] (interop/configurator-mcp/package-lock.json)
• Medium advisory (unsound): RUSTSEC-2026-0221 (Cargo.lock)
• SessionTools::read_environment_jobs (cognitive 16) (crates/temporal-server/src/worker/session_tools.rs)
• The 'Example Profiles' section shows how to import workspace-backed profiles but does not explain the CLI behavior when importing a non-empty JSON array of profile objects for batch import/check. (profiles/README.md)
• TooManyFunctions: crate (crates/eval/src/main.rs)
• drive::attach_promise_control_runtime (cognitive 18) (crates/engine/src/core/drive.rs)
• drive::tool_batch_deferred_proposals (cognitive 27) (crates/engine/src/core/drive.rs)
• drive::tool_batch_deferred_proposals (cyclomatic 21) (crates/engine/src/core/drive.rs)
• eval::run_cli (cognitive 19) (crates/eval/src/main.rs)
• storage::materialize_await_result (cognitive 18) (crates/temporal-server/src/worker/activities/storage.rs)
• …and 5 more

• 22 commits — 19 feature/other, 3 fixes

• crates/temporal-server — 5 commits
• docs/roadmap — 5 commits
• (repo) — 4 commits
• crates/eval — 2 commits
• crates/temporal-workflow — 2 commits
• .github/workflows — 1 commit
• crates/engine — 1 commit
• crates/host-bridge — 1 commit
• crates/tools — 1 commit

• fix: Merge pull request #34 from smartcomputer-ai/fixes
• fix: fix(host-bridge): expose native filesystem by default
• fix: fixed evals
• change: Declare session VFS topology with workspace links
• change: Implement joined workflow tools
• change: Merge pull request #32 from smartcomputer-ai/long-running
• change: Merge pull request #33 from smartcomputer-ai/envs2-squashed
• change: Merge pull request #35 from smartcomputer-ai/vfs2
• change: Redesign environment selection and runtime state handoff
• change: Trigger ls.bot image build on main pushes
• change: added list dir for antrhopic
• change: better await tool returns
• change: doc
• change: doc
• change: docs
• change: environment credentials handling
• change: job_run tool
• change: mcp refactor
• change: observability
• change: p111
• …and 2 more

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

smartcomputer-ai/lightspeed was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.