ultraworkers/claw-code

This system is a Rust-based CLI tool and runtime environment designed to manage and execute agent workflows. It provides a modular architecture for API interactions, session management, and tool execution, featuring a plugin system with pre/post hooks and a RAG service for workspace indexing. The codebase emphasizes security through strict workspace boundary enforcement and includes comprehensive testing for behavioral parity and integration scenarios.

Three new scripts are introduced in the rust/scripts directory to support behavioral testing of the CLI. The shell script run\_mock\_parity\_harness.sh executes the Rust test suite for the mock parity harness. The Python script run\_mock\_parity\_diff.py orchestrates the test run, validates references against PARITY.md, and reports on scenario coverage and results. Additionally, an install.sh script is added to build the release binary and link it to the user's local bin directory.

rust/scripts · high confidence

A new Rust crate, \compat-harness\, was added to parse and extract manifest data from the upstream TypeScript/JavaScript codebase. This includes identifying internal and feature-gated commands, base and conditional tools, and bootstrap phases, enabling Rust-based compatibility checks against the existing CLI structure.

rust/crates/compat-harness · high confidence

Two new bundled plugins, 'example-bundled' and 'sample-hooks', have been added to the Rust plugin system. Each includes a plugin.json manifest defining a PreToolUse and PostToolUse hook, along with corresponding shell scripts (pre.sh and post.sh) that execute before and after tool use respectively. These serve as reference implementations for plugin integration.

rust/crates/plugins/bundled · high confidence

The tools crate now automatically detects when a lane is completed (status finished/with no errors, green tests, and pushed code) and triggers policy actions to close out the lane and clean up the session. Additionally, a new PDF text extraction utility has been added to parse PDF content streams and extract readable text.

rust/crates/tools/src · high confidence

A new canonical board for Claw Code 2.0 has been generated, mapping 127 roadmap headings and 542 ordered actions to 732 board items. The board includes coverage metrics, lifecycle status enums, release bucket classifications, and stream summaries. This provides a structured, machine-readable view of the CC2 implementation surface, with each item linked to its source in ROADMAP.md and associated with verification requirements.

.omx/cc2 · high confidence

The \src/main.py\ entry point now exposes several new subcommands that expose internal state and execution paths: \setup-report\ renders the startup/prefetch setup report; \command-graph\ shows command graph segmentation; \tool-pool\ displays the assembled tool pool; \bootstrap-graph\ shows the mirrored bootstrap/runtime graph stages; \bootstrap\ builds a runtime-style session report; \turn-loop\ runs a stateful turn loop; \flush-transcript\ persists and flushes a temporary session transcript; \load-session\ loads a previously persisted session; \remote-mode\, \ssh-mode\, \teleport-mode\, \direct-connect-mode\, and \deep-link-mode\ simulate various runtime branching modes; \exec-command\ and \exec-tool\ execute mirrored command/tool shims. Additionally, the \commands\ and \tools\ subcommands now support filtering (\--no-plugin-commands\, \--no-skill-commands\, \--simple-mode\, \--no-mcp\, \--deny-tool\, \--deny-prefix\) and the command lookup now normalizes input and resolves aliases.

src · high confidence

The repository was initialized with core configuration files (\.claude.json\, \.claw.json\), a Docker build file (\Containerfile\), and key documentation files (\CLAUDE.md\, \PARITY.md\, \PHILOSOPHY.md\, \ROADMAP.md\, \CODE\_OF\_CONDUCT.md\, \CONTRIBUTING.md\, \LICENSE\). These files establish the project's operational guidelines, parity status, and development roadmap.

(repo-wide) · high confidence

The Rust crate \rust/crates/commands\ is introduced, providing a new command registry and slash command specification system for the CLI. This change brings the CLI's command surface to parity with the existing agents, skills, and plugins modules, enabling structured JSON responses for commands like \help\, \status\, \mcp\, and \config\. The implementation includes a \CommandRegistry\ and \SlashCommandSpec\ definitions that standardize how commands are discovered, validated, and executed, ensuring consistent error handling and output formats across the CLI.

rust/crates/commands · high confidence

A new Rust crate, claw-rag-service, provides a workspace RAG (Retrieval-Augmented Generation) system. It indexes text files from specified workspaces into a local SQLite database, generating text chunks and their embeddings. The service exposes an HTTP API (default port 8787) with endpoints for querying the index and retrieving stats. It supports two search backends: a default linear scan over the SQLite database and an optional Qdrant vector index (enabled via the qdrant-index feature). Users can run a CLI subcommand to ingest files or start the HTTP server to perform natural language searches against the local index.

rust/crates/claw-rag-service · high confidence

Added a new Rust crate, mock-anthropic-service, which implements a TCP-based mock server for the Anthropic API. This service captures incoming requests, identifies specific parity scenarios (such as streaming text, file roundtrips, and auto-compaction triggers), and returns simulated responses. This enables automated tests to verify that the CLI's behavior matches the real Anthropic API across various edge cases.

rust/crates/mock-anthropic-service · high confidence

The plugin subsystem now supports executing external scripts or commands at specific points in the tool-use lifecycle. Users can configure \PreToolUse\, \PostToolUse\, and \PostToolUseFailure\ hooks in plugin manifests, which will be executed by the new \HookRunner\. This allows plugins to run custom logic before, after, or upon failure of tool execution, with results (allow, deny, or fail) propagating back to the core system.

rust/crates/plugins/src · high confidence

A new telemetry crate has been added to the Rust codebase, providing structured data models for tracking HTTP requests and analytics. This includes a ClientIdentity struct for managing app name, version, and runtime, alongside an AnthropicRequestProfile that automatically injects the correct Anthropic API version headers and beta flags (such as claude-code and prompt-caching-scope) into outgoing requests. The crate also defines AnalyticsEvent and SessionTraceRecord structures to capture HTTP request lifecycle events (start, success, failure) and generic analytics, enabling detailed tracing of internal and external API interactions.

rust/crates/telemetry · high confidence

A new \claw-analog\ binary and library crate have been added, providing a lean agent tool-loop with optional streaming and permission enforcement. The CLI now supports three new subcommands: \doctor\ for environment and build sanity checks, \config validate\ to parse and preview \.claw-analog.toml\ and profile merges without calling the API, and \agents\ to run multiple specialized sub-agents (audit, explain, implement) sequentially. The library exposes core types like \PermissionMode\, \Preset\, and \AnalogLanguage\, and enforces non-interactive permission restrictions via \enforce\_non\_interactive\_permission\_rules\.

rust/crates/claw-analog · high confidence

The API layer now uses a unified \Provider\ trait and \ProviderKind\ enum to route requests to distinct backend implementations. This introduces native support for Anthropic (via \anthropic.rs\), OpenAI-compatible endpoints (via \openai\_compat.rs\), and specific integrations for xAI, Alibaba DashScope, and local Ollama instances. The change also adds request body size pre-flight checks, configurable retry policies with \Retry-After\ header support, and enhanced error context for API failures.

rust/crates/api/src/providers · high confidence

Added several new scripts to the \scripts/\ directory to support the CC2 board workflow and roadmap integrity. \cc2\_board.py\ acts as a wrapper to generate and validate the canonical board. \generate\_cc2\_board.py\ and \validate\_cc2\_board.py\ handle the specific generation and schema validation logic. \roadmap-next-id.sh\ and \roadmap-check-ids.sh\ manage and verify unique numeric IDs in \ROADMAP.md\ to prevent collisions. Additionally, \dogfood-build.sh\ and \dogfood-probe.py\ provide a build and verification tool for the 'dogfood' (internal use) workflow, ensuring binary provenance and safe execution of CLI commands.

scripts · high confidence

The Rust API client now supports configurable HTTP timeouts (connect and request) via environment variables, respects standard proxy environment variables (HTTP\_PROXY, HTTPS\_PROXY, NO\_PROXY), and implements a local prompt cache for Anthropic requests to reduce latency and cost. The client also exposes structured error types for API failures, including retry-after headers and actionable hints for missing credentials.

rust/crates/api/src · high confidence

The Rust CLI (rusty-claude-cli) is now implemented end-to-end, replacing the previous stubs. It introduces a new interactive setup wizard for configuring providers, API keys, and models. The CLI now supports structured JSON output for all commands, including init, status, config, and session management. Build-time metadata (Git SHA, branch, date) is embedded into the binary for versioning. The terminal rendering engine supports colored markdown output and spinner animations. The CLI also handles session persistence, auto-compaction, and tool execution with bounded recursion.

rust/crates/rusty-claude-cli/src · high confidence

The Rust runtime crate introduces a comprehensive suite of new modules that form the core of the new Rust port. This includes session compaction logic to manage context window limits, a bash execution tool with sandboxing and provenance tracking, and a robust configuration system with schema validation and deprecation warnings. Additionally, the runtime now supports approval tokens for policy exceptions, manages branch locks to prevent collisions, and handles file operations with strict workspace boundary enforcement.

rust/crates/runtime/src · medium confidence

Each Python package in the src tree (e.g., assistant, bootstrap, cli, etc.) no longer reads its own JSON snapshot file directly using json and pathlib. Instead, they all now import and use a shared \src.\_archive\_helper.load\_archive\_metadata\ function to load subsystem metadata. This unifies how archive names, module counts, and sample files are retrieved across the codebase.

(repo-wide) · high confidence

The system now records session metadata and user messages in JSONL files within the .claw directory. Each new session generates a corresponding JSONL file containing a session\_meta entry and the initial user message (e.g., 'doctor --help' or 'status --help'), enabling better tracking and debugging of user interactions.

rust/.claw · medium confidence

The .omx/ultragoal directory now contains the complete ultragoal ledger and goals state, including the completion of G010 (session hygiene/local state/recovery UX) and G009 (Windows/install/docs readiness). The G010 final quality gate log confirms that session control, JSONL persistence, and compaction tests pass, though an earlier iteration of the G010 leader verification log shows a transient failure in \session\_store\_fork\_stays\_in\_same\_namespace\ that was subsequently resolved in the final verification. The ledger.jsonl and goals.json files track the status of all 12+ stream goals, with G010 and G011 marked as complete and G012 (final release gate) also marked complete, while G013 is in progress.

.omx/ultragoal · high confidence

The session metadata file (session-newer.jsonl) has been updated to include a 'version' field, indicating a change in the structure of session data. This reflects a shift in how session information is stored and potentially parsed by the CLI tool.

rust/crates/rusty-claude-cli/.claw · low confidence

Added benchmarks for API request building performance; Added integration and conformance tests for the runtime; Added integration tests for API client, provider routing, and proxy configuration; Added path scope enforcement tests; Expanded test coverage for CLI flags, compact output, and session resume behavior; Expanded test coverage for workspace security, pre-push hooks, and CLI commands.

The project now includes a Rust workspace with a new \Cargo.lock\ and multiple \Cargo.toml\ files defining the internal crate structure (e.g., \api\, \claw-analog\, \claw-rag-service\, \commands\, \plugins\, \runtime\, \rusty-claude-cli\, \telemetry\, \tools\). This establishes the foundational build system and dependency graph for the Rust port of the CLI, organizing the code into distinct modules for API handling, runtime execution, and tooling.

(dependencies) · high confidence

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

• CAI 56 → 56 (+0.0)

• Code Health 73 → 73 (+0.0)
• Architecture 97 → 97 (+0.0)
• Maturity 55 → 55 (+0.1)
• Readiness 46 → 46 (+0.0)
• Security 63 → 63 (+0.0)
• Domain Modelling 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 78 → 78 (+0.0)

• Build action pinned to a mutable branch
• Further orphaned files (smaller)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• Off-boarding risk: anonymized user #4

• Off-boarding risk: anonymized user #3
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2

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

ultraworkers/claw-code 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.