Skip to content
CAI
Software that uses CAICheck a score

JuliusBrussee/caveman

57.7

Adequate · 13 November 2026

141.6k

lines of production code

Go

with TypeScript, JavaScript, Python

8

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Codex SessionStart hook to respect defaultMode configuration

Introduces a new Codex integration via \.codex/hooks.json\ and \config.toml\ that activates the Caveman mode on session start. The new \codex-sessionstart.js\ hook resolves the configured \defaultMode\ (from environment variables, repo-local, or user config) and injects the appropriate skill rules, replacing the previous static echo that ignored user settings. This ensures Codex sessions behave consistently with the Claude hook regarding mode activation and rule injection.

.codex · high confidence

Added CommonJS type shim generation script

A new script (cjs-types.mjs) was added to automatically generate .d.cts type declaration shims for CommonJS consumers. This ensures that TypeScript projects using moduleResolution: node16 can correctly resolve types via the 'default' export branch without encountering TS1479 errors, while preventing TS1361 value-import errors by merging value and type exports into a single namespace.

packages/sdk/typescript/scripts · high confidence

Added black-box conformance kit for middleware protocol validation

A new executable conformance kit (\run.mjs\) has been added to validate any Caveman middleware runtime against the defined protocol. It performs black-box HTTP checks—verifying JSON schema compliance, required headers, and specific error codes—and outputs TAP results. The kit supports both protocol 1.0 and 1.1 views, allowing users to verify runtime behavior, including version skew scenarios, via command-line flags.

packages/shared/contracts/conformance · high confidence

Added build scripts for the Pi extension

A new build script (bundle.mjs) has been added to the packages/pi-extension/scripts directory. This script uses esbuild to bundle the extension's source code (src/index.ts and src/testable.ts) into ESM format for Node.js 22, outputting the results to the dist directory.

packages/pi-extension/scripts · high confidence

Caveman 2.0 release: new proxy routing, SDK, and tool compression

This release introduces the Caveman 2.0 engine, proxy, and SDKs, along with a unified CLI. The proxy now includes an Azure OpenAI adapter that enforces strict routing and an allowlist of API versions (configurable via \CAVE\_AZURE\_API\_VERSION\_ALLOWLIST\) and adds a session-usage tracking interface for cost and token reporting. A new \caveman-shrink\ CLI tool compresses MCP and OpenAI tool catalogs to reduce token usage, with a fail-safe recovery mechanism for original data. The Python SDK (\caveman\_cloud\) is updated to expose core client and policy interfaces, and the engine includes new evaluation fixtures for inventory rollups.

(repo-wide) · high confidence

Caveman 2.0.0 release with new engine, proxy, and middleware architecture

This release introduces Caveman 2.0.0, featuring a new compression engine (engine/result.go) that supports record and compress modes with local token estimation, a ChatGPT-subscription proxy route (proxy/internal/gateway/chatgpt.go) that handles OAuth passthrough and zstd body compression, and a new middleware runtime (proxy/internal/middleware/runtime.go) with scoped grants, capacity limits, and a new middleware store schema (proxy/internal/store/middleware.go) for managing originals and scopes. It also includes a repository intelligence system (proxy/internal/repointel/index.go) that builds bounded, deterministic local repository maps and evidence bundles with direct evidence filtering.

github.com/JuliusBrussee/caveman · high confidence

Caveman Mode browser extension (v1.3.0) ships with MV3 architecture and site-specific directive injection

The extension now uses Manifest V3 with a service worker background and content scripts that intercept outgoing messages on ChatGPT, Claude, and Gemini to prepend a 'caveman' directive, ensuring replies are compact while preserving technical substance. Users can toggle the feature and choose between three modes (caveman, ultracave, megacave) via the popup, with per-site controls and local-only storage. The update includes a new 'Leave a review' CTA in the popup (hidden on Firefox until AMO verification), a visible on-page indicator, and a 'stop caveman' command to disable the extension. The extension is now licensed under Apache-2.0.

extension · high confidence

Caveman hooks: per-session mode state, subagent inheritance, and non-Claude host support

The hooks in src/hooks now manage mode state per session rather than globally, using a session-scoped directory ($CLAUDE\_CONFIG\DIR/.caveman-sessions) while keeping a legacy mirror for compatibility. The SessionStart hook (caveman-activate.js) now injects the active skill as hidden context, degrades gracefully when sibling modules are missing, and starts headless/SDK sessions in manual mode by default. A new SubagentStart path (caveman-activate.js --subagent) passes the parent session's active skill to subagents without writing state. A new UserPromptSubmit hook (caveman-mode-tracker.js) handles slash commands and natural-language triggers with improved negation and envelope parsing, and supports one-shot independent modes (commit, review, compress) that remember the previous prose mode. Per-agent model overrides are now applied via environment variables (CAVECREW\\*\_MODEL) through cavecrew-model-overrides.js, with safeguards against rewriting source checkouts. A new host-session-start hook (caveman-host-session-start.js) provides session context for Cursor and Copilot. The statusline scripts (caveman-statusline.sh/ps1) now render per-window badges and ignore the legacy savings suffix. All state writes use safeWriteFlag (symlink-refusing, atomic, 0600), and reads are whitelist-validated.

src/hooks · high confidence

Caveman init tool now supports idempotent updates and multiple IDE agents

The new \caveman-init.js\ tool allows users to install the Caveman activation rule across various IDE agents (Cursor, Windsurf, Cline, Copilot, OpenCode, and OpenClaw) in an idempotent manner. It uses fenced markers for shared files to safely refresh or remove the rule without corrupting user content, and handles atomic writes to prevent corruption during interrupted runs. The tool also respects the \--force\ flag for refreshing existing rule files and supports a \--dry-run\ mode for previewing changes.

src/tools · high confidence

Engine documentation and CCR security hardening

The engine area now includes comprehensive documentation (AGENTS.md, CLAUDE.md, README.md) and an Apache-2.0 license, clarifying the local, recoverable context compression workflow and the stable four-call API. The Context Content Recovery (CCR) store has been hardened with platform-specific security measures: POSIX systems now use O\_PATH descriptors and fchmodat2/procfs to change file permissions without dropping SQLite locks, Windows uses native ACL checks and handle-based locking, and Android support is improved with seccomp-safe chmod fallbacks and hard-link fallbacks for filesystems that do not support them. Also in this area: 1 commit (1 fix) fixing engine; 8 commits (5 fixes) fixing engine/ccr; Engine fixes for diff compression, terminal detection, and Codex output handling; Fix HTML detection for pages with stray carriage returns.

engine · medium confidence · unverified

Firefox packaging and verification tooling

The extension build process now supports a dedicated Firefox target. A new build script stages shared runtime files flat at the root to comply with WebExtensions restrictions, swaps in a Firefox-specific manifest, and packages the result into a zip file. A verification script enforces a strict allowlist of shippable files and validates that content-script CSS does not use relative URLs that would fail when injected into third-party pages. An end-to-end test script automates the installation of the staged build in a real Firefox instance via web-ext to verify content script injection.

extension/scripts · high confidence

Initial release of the TypeScript SDK with core types and interfaces

The TypeScript SDK package is introduced, providing the foundational type definitions and interfaces for interacting with the Caveman platform. This includes configuration options for API keys, base URLs, and timeouts, as well as detailed types for tracing, tool management, and context packing. The release establishes the contract for the client-side SDK, defining how users configure the client, manage tool schemas, and handle assembly stability errors, serving as the primary interface for building applications against the Caveman engine.

packages/sdk/typescript/src · high confidence

Introduce Caveman 3.0 Python middleware with framework adapters and recovery capabilities

This release introduces the Caveman 3.0 Python middleware package, providing native adapters for major AI frameworks including AutoGen, Google GenAI, LangChain, LiteLLM, and Pydantic AI. The middleware enables structured content recovery and usage tracking by wrapping framework-specific clients and transports. Key features include a fail-open guard for robust error handling, scope resolution for context management, and native HTTP transport instrumentation for accurate usage reporting across different SDK versions.

_packages/middleware/python/caveman\middleware · high confidence

Introduce Caveman Browse: token-efficient browser interaction via MCP

The \browse\ area now ships a local browser-interaction MCP server (\caveman-browse\) that attaches to Chrome, reads the full accessibility tree, and compresses it using the engine's \a11y\ compressor to deliver a compact, agent-visible snapshot. It exposes four tools—\browser\_snapshot\, \browser\_act\, \browser\_eval\, and \browser\_recover\—allowing users to navigate pages, perform actions (click, type, select) on specific UI elements via UIDs, run JavaScript, and recover the exact original AX payload via CCR handles. The implementation enforces strict safety and efficiency: it fails closed if compression does not reduce the tree size (avoiding raw AX dumps), keeps prior UIDs intact on failure, treats cross-origin iframes as leaves, and reports actions as \settled:false\ until a focused resnapshot proves state. Large pages benefit from query-focused progressive disclosure, while benchmarks and integration tests validate token savings, auto-scrolling, stale-UID rejection, and byte-exact recovery.

browse · high confidence

Introduce Caveman Cloud Python middleware runtime (protocol 1.1)

Adds the \caveman\_cloud.middleware\ package, implementing the middleware protocol 1.1 client for the Python SDK. This runtime provides synchronous and asynchronous execution paths with bounded, lifecycle-owned I/O workers, ensuring that every operation (optimize, retrieve, receipt) is deadline-bound to prevent host stalls. It includes a stdlib-only HTTP transport with keep-alive pooling, DNS/connect/TLS watchdogs, proxy support, and automatic retry on stale connections. The module also enforces strict validation of untrusted runtime responses (plans, recovery pages) before any native edits are applied, and supports fork-safe worker initialization for environments like Gunicorn.

_packages/sdk/python/caveman\cloud/middleware · high confidence

Introduce Caveman Mode extension with multi-site support

Adds a new browser extension that intercepts the 'send' gesture on ChatGPT, Claude, and Gemini to prepend a 'caveman' style directive to outgoing messages. The feature includes a background script to manage the toolbar badge state, a content script with resilient, per-site selectors for editors and send buttons, and a directive module that supports three modes (caveman, ultracave, megacave) with legacy compatibility. The extension also includes a visual indicator styled with system monospace fonts to avoid 404 errors from missing font assets.

extension/src · high confidence

Introduce Caveman native extension for Pi

Adds the \@caveman-ai/pi\ extension, which bridges the Pi coding agent to the Caveman native runtime to enable context compression and recovery. The extension registers a \caveman\_retrieve\ tool for recovering compressed context, routes provider traffic through a local proxy when verified, and manages lifecycle hooks to keep the runtime alive. It includes Windows-safe command resolution, robust error handling to prevent host crashes, and configuration reading from \cloud.json\ to target the correct gateway.

packages/pi-extension/src · high confidence

Introduce JSON Splice provider with safe, byte-preserving JSON editing

A new \jsonsplice\ provider has been added to the proxy, enabling precise, byte-level modifications to JSON payloads without re-encoding or altering whitespace and escape sequences. The implementation includes a custom parser that navigates JSON structures (objects, arrays, strings) and applies targeted replacements or field insertions. To prevent integer overflows and excessive memory usage, the provider bounds input and replacement sizes to 1 GB (1 \<\< 30 bytes), rejecting any operation that exceeds this limit. Comprehensive tests verify that the splicer correctly handles nested structures, preserves original bytes for unchanged content, validates input ranges, and safely rejects malformed JSON or invalid span arguments.

proxy/providers/jsonsplice · high confidence

Introduce TypeScript middleware client for Caveman Protocol 1.1

The TypeScript SDK now includes a new \@caveman-ai/sdk/middleware\ package that implements the Protocol 1.1 client. This addition provides a \MiddlewareRuntime\ class for managing content optimization and recovery, featuring a built-in circuit breaker, strict scope and endpoint validation, and support for proxy routing and OpenTelemetry tracing. It also exposes protocol-level utilities for budget planning, deadline resolution, and plan validation, enabling adapters to interact with the Caveman middleware runtime.

packages/sdk/typescript/src/middleware · high confidence

Introduce agent profile registry and conformance tooling

The agents area now ships a structured agent profile registry (agents.json) that defines how external CLI agents like Claude Code, Codex, and Kilo are installed, injected, and hooked. To support this, a new build-time compiler (compile.mjs) validates profiles against a strict schema and emits a generated TypeScript copy for the CLI, while a new conformance probe (probe-installed.mjs) and drift reporter (drift-report.mjs) verify that installed binaries match pinned versions and open issues when they drift or break. A new scope-checker (check-profile-scope.mjs) enforces that profile changes stay within the agents lane, and a reserved-verbs list (reserved-verbs.json) prevents CLI command collisions.

agents · high confidence

Introduce benchmarking suite to measure Caveman's token savings

A new benchmarking suite has been added to the project to quantify the cost and efficiency improvements of the Caveman skill. The suite includes a Python runner (\benchmarks/run.py\) that executes a set of predefined coding and debugging prompts against the standard Claude assistant, a 'terse' control instruction, and the Caveman skill, then calculates output token savings. It also features a charting script (\benchmarks/render\_charts.py\) that generates static SVG visualizations of these savings for the documentation. The implementation addresses security concerns by strictly limiting environment variable loading to the \ANTHROPIC\_API\_KEY\ and fixes cross-platform encoding issues to ensure reliable execution on Windows and macOS.

benchmarks · high confidence

Introduce caveman-middleware Python SDK with native framework adapters

The caveman-middleware Python package is now installable and testable, providing native adapters for major LLM frameworks including Agno, Anthropic, CrewAI, LlamaIndex, and OpenAI, alongside a pure ASGI middleware for explicit LLM routes. The SDK enforces strict version compatibility ranges for each framework (e.g., OpenAI 2.x–3.x, Anthropic 1.x, LangChain 1.1–2.x) to ensure stable behavior, and implements a native manifest system that safely digests message history into bounded, JSON-serializable views for lineage tracking. It also introduces a native recovery tool mechanism, allowing agents to resume interrupted tool calls seamlessly across supported frameworks.

caveman-middleware · high confidence

Introduce caveman-shrink MCP middleware to compress tool descriptions

A new stdio proxy, caveman-shrink, is available to wrap any MCP server and compress prose fields (such as tool descriptions) in list responses. This reduces the token count the model must process without altering tool semantics or mutating request bodies and call responses. The proxy handles cross-platform spawning (including Windows .cmd shims), manages graceful shutdown with signal escalation, and can be configured via environment variables to target specific fields or enable debug logging.

src/mcp-servers · high confidence

Introduce cavemem CLI and MCP server for durable agent memory

The new \cavemem\ command-line tool and its associated MCP server provide a complete interface for managing durable agent memory. Users can store, recall, supersede, and delete memories via CLI subcommands or through the MCP protocol, with results returned as structured JSON. The tool supports configurable recall limits and token budgets to control context usage, and includes a \version --json\ command to expose schema and capability metadata for integration probing.

mem/cmd · high confidence

Introduce cavemem: durable, compression-native agent memory with bounded recall

The \mem\ component now provides durable, cross-session memory storage backed by a local SQLite database. Memories are stored raw to ensure byte-safety, then compressed via the engine at recall time to keep inferred token costs honest while retaining a recovery handle for the original text. Recall uses deterministic BM25 scoring with a conservative threshold to fail toward nothing on off-topic queries. The system enforces strict bounds: a default 2000-token budget per recall (overridable to unlimited), a 256 KiB limit per memory, and single-writer concurrency controls to prevent SQLite contention. It exposes \remember\, \recall\, \supersede\, \history\, and \forget\ operations via a Go API, a CLI, and thin JS/Python clients. Also in this area: 1 commit adding/updating tests in mem.

mem · high confidence · unverified

Introduce framework-specific middleware adapters for AI SDK, Anthropic, Google, and LangChain

This release adds new TypeScript middleware adapters for the AI SDK, Anthropic, Google GenAI, and LangChain frameworks, enabling content compression and recovery capabilities within these environments. Each adapter integrates with its respective framework's native client or model interface to intercept calls, apply optimization plans, and manage recovery bindings. The adapters include compatibility gates that verify installed framework versions against supported ranges, ensuring stable operation. Additionally, the package enforces a Node.js runtime requirement, explicitly blocking edge runtimes like workerd and edge-light due to their lack of support for necessary Node.js APIs. Also in this area: 5 commits (4 fixes) fixing packages/middleware.

packages/middleware/typescript/src · medium confidence · unverified

Introduce local repository intelligence with deterministic evidence bundling

The proxy now includes a new local repository intelligence system (repointel) that builds deterministic maps of project source files and generates task-specific evidence bundles. This system restricts evidence to project source only, requiring direct path or symbol matches to qualify for model visibility, while filtering out dependency trees and sensitive content. It supports both CGO-based tree-sitter parsing and a conservative Go-AST fallback, ensuring consistent, reproducible results for local repository context.

proxy/internal/repointel · high confidence

Introduce modular feature system with signed binary distribution

The CLI now manages capabilities as discrete modules (output, input, waste-fixes, routing, scripts, browse) that users can toggle with \caveman on\|off\. This change introduces a signed module index and a local lockfile to verify and install module-specific binaries, ensuring integrity. It also consolidates configuration into a single \\~/.caveman\ directory, migrating data from the legacy \\~/.caveman-cloud\ path while maintaining backward compatibility for older CLI versions. The system includes a new onboarding flow that presents a single-screen setup, provider login management, and a doctor command to diagnose and fix local runtime or wiring issues.

packages/cli/src/modules · high confidence

Introduce native pre-tool hook with repository state awareness and security hardening

The proxy now intercepts pre-tool events (such as file reads or searches) via a new native hook in \proxy/internal/nativehook\. For supported agents, the hook gathers the current repository state (via a bounded \git status\ call) and file currentness hashes, sending this context to the native runtime to enable more precise policy decisions. The implementation includes security hardening by explicitly ignoring repository-controlled commands (like \core.fsmonitor\) to prevent execution of untrusted code, and it ensures fail-open behavior by recording bounded fallback metadata rather than sensitive payload details when the native runtime is unavailable.

proxy/internal/nativehook · high confidence

Introduce native-pack v1 with mandatory Core instructions and six classified skills

The proxy now embeds a compiled native-pack (schema caveman.native-pack.v1, version 2.2.0) that enforces a mandatory Core instruction set and six classified skills—investigate-first, lean-build, migration, safe-refactor, surgical-patch, and verify-and-stop—each with defined entry/stop conditions, guardrails, and token budgets. The pack includes target-specific activation mappings for Claude, Codex, Hermes, Gemini, OpenCode, and Aider, and the Go loader validates schema identity, Core budget constraints, unique skill IDs, and conflict resolution before exposing a Select API that picks the highest-precedence skill for a given task type. Tests confirm the pack loads correctly, all six skills are present, selection works for known task types, and unknown types fail closed to Core.

proxy/internal/nativepack · high confidence

Introduce signed binary installation and secure launcher for caveman-browse

The \browse/bin\ area now includes a new binary installer (\binary-installer.generated.mjs\) that downloads prebuilt Go binaries for \caveman-browse\ from GitHub releases, verifying them against a signed checksum manifest using a hardcoded public key. A new launcher script (\caveman-browse.mjs\) uses this installer to locate or fetch the verified binary, ensuring that concurrent installs do not cross-contaminate by using unique \.part\ files during download and handling Windows file-locking issues during replacement. The system supports explicit binary paths via the \CAVEMAN\_BROWSE\_BIN\ environment variable and falls back to a local cache in \CAVEMAN\_HOME/bin\. Tests (\launcher.test.mjs\) verify the launcher's behavior, including failure when the explicit binary is missing and correct usage of the cached binary over the npm shim.

browse/bin · high confidence

Introduce subagent-tax to measure coding harness prefix overhead

A new local measurement tool, subagent-tax, is available to quantify the size of the system prompt and tool schemas (the 'prefix') that coding harnesses like Claude Code, Codex, Gemini, and OpenCode send on every agent call. The tool runs a local HTTP sink to capture these first requests from installed harnesses, analyzes the JSON character counts, and reports the breakdown of system instructions versus tool schemas (including MCP plugin contributions where identifiable). It provides both estimated token counts (calibrated against Anthropic's tokenizer) and optional exact counts via Anthropic's API, while ensuring no provider API calls are made by default and sensitive data is redacted in the generated repro packs.

packages/subagent-tax · high confidence

Introduce token-compression and fidelity evaluation harnesses for caveman skills

The \evals/\ directory now provides a complete, deterministic evaluation framework to measure how much token compression caveman skills provide and whether they preserve factual correctness. The harness runs prompts through Claude Code under three conditions—no system prompt, a generic terseness instruction, and the terseness instruction plus a specific skill—to isolate the skill's actual contribution. It captures real LLM outputs and Claude-reported usage metrics (input, output, cache tokens, and cost) in committed JSON snapshots, which are then analyzed by \measure.py\ to report median, mean, min, max, and standard deviation of token savings. A separate fidelity eval uses fixed correctness cases with regex-based checks to ensure skills do not drop critical facts, negations, or safety wording. The system supports multiple languages (English, Portuguese, French) with isolated runs to prevent host-side plugins or settings from skewing results, and includes a dedicated script (\reminder\_run.py\) to evaluate the impact of the caveman-mode-tracker hook across different skill levels.

evals · high confidence

Introduces secure, validated proxy run-state management

The proxy now maintains an out-of-band state file (JSON) to communicate its status to the CLI, ensuring safe interactions through strict validation. This state includes a unique instance token and process ID, which are verified against the running process and listener identity to prevent race conditions or trust issues with stale or foreign state. The implementation writes the state atomically with restricted file permissions (0600) and provides platform-specific process querying (Windows vs. non-Windows) to support these integrity checks.

proxy/internal/runstate · high confidence

Introduces the native runtime subsystem for deterministic local-agent session management

The \proxy/internal/nativeruntime\ package is added to provide a local, deterministic runtime for managing agent sessions. It introduces a strict 250ms hook deadline to ensure fail-open behavior even when the underlying SQLite store is write-locked, preventing session stranding. The runtime includes session marker injection and stripping for provider correlation, structured tool output masking with recoverability references, and a decision ledger for auditability. It also generates detailed session receipts and handles repository state warming and pruning.

proxy/internal/nativeruntime · high confidence

Native Caveman plugin for OpenCode (v1.x and v2.x)

A new native plugin replaces the previous npx-skills fallback, providing dynamic mode tracking for the Caveman feature within OpenCode. The plugin uses OpenCode's lifecycle hooks to write a mode flag on session start, parse slash commands and natural-language toggles for mode changes, and inject per-turn reinforcement into the system prompt. It supports both OpenCode 1.x and 2.x via separate entry points (plugin.js and server.js) and includes an installer that configures the plugin directory and patches opencode.json.

src/plugins/opencode · high confidence

New AWS Bedrock provider adapter with routing, signing, and cache support

The proxy now includes a dedicated AWS Bedrock provider adapter that enables routing to Bedrock Runtime and the opt-in Mantle endpoint, enforcing strict allowlists for regions, models, and actions. It handles AWS SigV4 signing over the exact upstream wire bytes, strips hop-by-hop headers, and supports both API-key and IAM authentication. The adapter also injects provider-native cache markers for Anthropic Claude models on supported endpoints and parses Bedrock-specific usage telemetry, including cache hit/write statistics. Also in this area: 3 commits (3 fixes) fixing proxy/providers.

proxy/providers/bedrock · medium confidence · unverified

New Anthropic provider adapter with prompt-cache optimization and routing fixes

The proxy now includes a dedicated Anthropic provider adapter that supports both gateway-prefixed and bare Anthropic wire-protocol routes (e.g., /v1/messages, /v1/models). This adapter enables two prompt-cache strategies: an explicit breakpoint optimizer that places ephemeral cache markers on stable prefixes (last tool, system tail, or message frontier) for pay-as-you-go sessions, and an automatic top-level cache marker for direct Messages requests. It also implements content compression by identifying and compressing only the live, uncacheable tail of conversations while preserving frozen prefix bytes. Routing fixes ensure bare /v1/models requests are handled via the wire protocol and that Anthropic/Google keys are kept off the OpenAI models route, preventing 404s and key leakage.

proxy/providers/anthropic · high confidence

New CLI and Blocks telemetry ingestion endpoints

Added Supabase Edge Functions (\cli-telemetry\ and \blocks-telemetry\) and database migrations to receive and store telemetry data from the CLI and Caveman Blocks. The \cli-telemetry\ function ingests CLI usage events (commands, sessions, token usage) into \public.cli\_events\, while \blocks-telemetry\ ingests block usage events into \public.blocks\_events\. Both endpoints enforce strict input validation, rate limiting, and IP-based anti-abuse measures, and are configured in \supabase/config.toml\ to allow anonymous POST requests.

supabase · high confidence

New CLI build and release automation scripts

The CLI package now includes a suite of build and release scripts that automate the generation of release constants, module indexes, and bundled assets. These scripts handle compiling the TUI and Pi extension, bundling delegate modules, generating signed binary release metadata, and preparing the wedge installer, ensuring the CLI ships with up-to-date, signed, and bundled components.

packages/cli/scripts · high confidence

New Caveman Delegate tool for bounded subtasks

The agents/delegate area now includes a new stdio-based MCP server (caveman-delegate-mcp.mjs) that exposes a single 'caveman\_delegate' tool, allowing users to run bounded, mechanical subtasks (such as search, test runs, or log triage) in a token-efficient worker agent. This tool spawns a child process using a new portable-process.mjs module, which ensures cross-platform compatibility (Windows/macOS/Linux) by handling Windows command shims, process isolation, and safe cleanup. The delegate returns the worker's report along with provider-reported usage metrics (input/output tokens, cache reads/writes, and cost). Tests in portable-process.test.mjs verify the cross-platform process spawning and cleanup logic.

agents/delegate · high confidence

New OpenAI provider adapter with caching, compression, and token counting

The proxy now includes a new OpenAI provider adapter that introduces several capabilities to improve performance and cost tracking. It injects a stable \prompt\_cache\_key\ to increase cache-hit rates for long prompt prefixes, compresses live user and tool message content to reduce payload size, and implements accurate token counting for the Responses API by projecting requests to the dedicated input-tokens endpoint. Additionally, it offers an optional output-brevity feature to cap generation length and ensures data integrity by preventing integer rounding errors during JSON processing and rejecting malformed requests with trailing bytes.

proxy/providers/openai · high confidence

New agent skills and MCP client for CLI telemetry and workflow management

The CLI now includes a new \agent-mcp.ts\ module that implements an MCP client for interacting with the Caveman Cloud API, enabling features like trace search, report retrieval (costs, savings, workflows), and experiment management. Additionally, a new generated file \agent-skills.generated.ts\ bundles a set of built-in agent skills (such as \caveman\, \caveman-discover\, \caveman-learn\, \caveman-setup\, and \caveman-manage\) that allow the CLI to guide users through repository wiring, cost analysis, and experiment lifecycle management directly within the agent interface.

packages/cli/src · high confidence

New caveman skills and cavecrew delegation system

This change introduces several new skills and a delegation framework to the skills directory. The \caveman-commit\ skill generates terse, Conventional Commits-formatted messages. The \caveman-compress\ skill compresses natural language memory files (like CLAUDE.md) into a concise format to save tokens, complete with a Python-based CLI, validation, and backup management. The \caveman-discover\ skill identifies LLM workflows in a repository for spend tracking. Additionally, the \cavecrew\ skill provides a decision guide for delegating tasks to specialized subagents (\cavecrew-investigator\, \cavecrew-builder\, \cavecrew-reviewer\) to keep main context usage low. An \activation-rule.mjs\ script is also added to derive always-on activation rules from the main caveman skill definition.

skills · high confidence

New caveman-shrink CLI for compressing and recovering tool catalogs

The \caveman-shrink\ command-line tool is now available to compress MCP/OpenAI tool catalogs via stdin/stdout, with a fail-open behavior that preserves original data if compression fails. Users can also inspect per-tool token reductions using the \lint\ subcommand and recover original catalogs from durable handles using \recover\. The tool exposes a \version --json\ endpoint that reports the schema version and supported capabilities (shrink, lint, recover) for CLI probing.

shrink/cmd · high confidence

New framework-recipe registry for AI SDK integrations

The integrations area now ships a declarative recipe registry that provides one-line base-URL routing snippets for 12 AI SDKs and frameworks (including OpenAI, Anthropic, Google Gen AI, LangChain, LiteLLM, CrewAI, Vercel AI SDK, Pydantic AI, and curl). A zero-dependency build-time compiler (compile.mjs) validates these recipes against the provider pricing catalog and emits a published registry (recipes.json) along with embedded TypeScript copies for the CLI and the web app, ensuring that every shipped model ID is priced and correctly referenced.

integrations · high confidence

New high-performance translator for Anthropic Messages, OpenAI Chat, and OpenAI Responses

The proxy now includes a new translation layer in \proxy/internal/translate\ that converts request and response bodies between three wire grammars: Anthropic Messages, OpenAI Chat Completions, and OpenAI Responses. This enables clients using one grammar (such as Claude Code using Messages, or Codex using Responses) to interact with upstream providers speaking a different grammar (e.g., running a GPT model via the Responses API or a Claude model via Chat Completions). The implementation uses a custom byte-level JSON reader (\jsonfast.go\) to copy conversation history without decoding, ensuring that earlier turns render identically across requests to support prefix caching. It also handles complex features like reasoning effort mapping across different dialects, encrypted thinking signature replay, and tool call translation.

proxy/internal/translate · high confidence

New local provider pool with ChatGPT OAuth support

The proxy now includes a local provider pool that manages API keys and OAuth logins for routing requests to various AI hosts. This change introduces a new 'Sign in with ChatGPT' flow, allowing users to authenticate via an OAuth authorization-code flow with PKCE, which stores tokens locally and handles background refreshes. The pool is configured via an embedded \providers.json\ registry that defines supported providers (such as OpenAI, Anthropic, DeepSeek, and OpenRouter), their available models, and the specific API 'wires' (e.g., Responses, Messages, Chat) they support. This enables the runtime to automatically select appropriate providers and credentials based on the agent's request type and the user's configured logins.

proxy/internal/pool · high confidence

New middleware runtime with compression, recovery, and HA support

The proxy middleware now implements a full runtime for protocol 1.1, introducing content compression via the Caveman Engine, automatic recovery of originals via handles, and support for high-availability Postgres stores with schema migrations. It enforces strict namespace-based authorization, per-principal quotas, and fair queueing to prevent resource starvation, while exposing Prometheus metrics and audit logging for operational visibility.

proxy/internal/middleware · high confidence

New multi-source identity resolution for proxy middleware

The proxy now supports four distinct authentication mechanisms to identify callers and enforce namespace access: a legacy shared token, a rotatable token map file, OIDC/JWT verification against a JWKS endpoint, and mutual TLS (mTLS) client certificates. This change introduces the \proxy/internal/identity\ package, which resolves the authenticated principal, maps them to allowed namespaces via glob patterns, and applies per-principal quotas. It also adds runtime-reloadable TLS configuration for the listener, allowing certificate and CA updates without restarts, and ensures strict separation between identity sources to prevent cross-source principal impersonation.

proxy/internal/identity · high confidence

New platform primitives for AWS credential resolution, SigV4 signing, and TLS trust management

The shared/platform area now includes three new packages that provide foundational capabilities for the proxy. The awscreds package implements a lightweight, standard-library-only credential chain (environment, web identity, container, and IMDSv2) with strict security controls that prevent secret leakage in errors and block plaintext requests to non-loopback container endpoints. The awssig package provides a deterministic AWS Signature Version 4 signer that correctly handles path canonicalization for Bedrock and S3, verified against botocore fixtures. The cabundle package offers a fail-closed TLS certificate pool builder that strictly validates PEM bundles to prevent partial trust from corrupt files. Comprehensive tests are included for all three packages.

shared/platform · high confidence

New provider adapter layer with usage parsing, credential mapping, and compression coverage

The proxy now includes a new provider adapter layer (adapter.go) that handles request inspection, credential mapping, and usage parsing for OpenAI, Anthropic, Gemini, Bedrock, and Vertex. This layer ensures that client credentials are never leaked upstream, resolves provider-specific credential headers (e.g., x-goog-api-key for Google), and parses usage data from both streaming and non-streaming responses, including raw usage preservation for re-pricing. It also introduces a compression coverage matrix (compression\_coverage.go) that defines which routes support byte-splice extraction and server-recovery grammars, ensuring that accounting endpoints and unsupported routes are explicitly handled. Additionally, agent path splitting (agentpath.go) allows for attribution paths like /w/\<slug\>/... to be parsed and validated.

proxy/providers · high confidence

New release, installation, and compatibility tooling for Caveman 2.0.0

This change introduces a suite of new scripts to support the Caveman 2.0.0 release. The \build-release-binaries.mjs\ script enables cross-compilation of the proxy, engine, and other binaries for macOS, Linux, and Windows, utilizing Zig for cgo builds and ensuring reproducible, static binaries. The \install-local-cli.sh\ and \install-local-cli.ps1\ scripts provide a one-command setup for local development, building the CLI and Go companions, and installing shims to \.local-bin/\ to avoid conflicts with system paths. Additionally, \sign-binary-checksums.mjs\ adds cryptographic signing for release artifacts, \probe-native-codex-recovery.mjs\ provides a macOS-specific test for native Codex recovery, and \test-windows-compat.mjs\ establishes a comprehensive compatibility gate for Windows environments.

scripts · high confidence

New shared device-auth package for OAuth 2.0 Device Authorization Flow

The \packages/device-auth\ package introduces a shared implementation of the OAuth 2.0 Device Authorization Grant flow. It provides the \runCavemanDeviceFlow\ function to handle the full lifecycle: requesting a device code, polling for the access token, and managing retry logic (including backoff on \slow\_down\ errors). The package also exposes a \DeviceGrant\ object with an \acknowledge()\ method, which ensures durable credential delivery by posting an acknowledgement token to the server only after the client has successfully persisted the credentials. Additionally, it includes a utility \nextDevicePollIntervalMs\ for calculating poll intervals and exports the necessary TypeScript interfaces (\DeviceCode\, \DeviceCredentials\, \DeviceGrant\) for type safety.

packages/device-auth · high confidence

Standalone proxy authentication, credential routing, and middleware runtime

The standalone proxy now enforces inbound authentication via a shared operator token (accepted in \x-cave-api-key\ or \Authorization: Bearer\), which is consumed and never forwarded to upstream providers. Provider-specific credential routing is hardened: AWS Bedrock resolves signing credentials from the AWS default chain (ECS task role, EKS pod identity, etc.) while strictly failing closed on partial environment variables; Google Gemini respects \?key=\ query parameters and OAuth tokens while rejecting conflicting credential sources; and custom headers are forwarded only on explicitly configured compat mounts. Additionally, a new middleware runtime is introduced, supporting multi-principal identity resolution (token maps, OIDC, mTLS), encryption keyrings, and configurable retention and quota limits.

proxy/internal/standalone · high confidence

Unified cross-platform installer replaces shell scripts with a single Node.js script

The installer is now a single, pure-stdlib Node.js script (installer/install.js) that replaces the previous quartet of shell and PowerShell scripts (install.sh, install.ps1, and their hook counterparts). This consolidation eliminates platform-specific quoting bugs, ensures consistent behavior across macOS, Linux, and Windows, and pins remote fetches to a specific release tag (v4.0.1) to prevent silent changes from the main branch. The new installer handles hook installation, plugin management, and uninstallation with improved error reporting and state awareness, while maintaining zero runtime dependencies.

installer · high confidence

caveman-shrink: durable, reversible tool-catalog compression

The \shrink\ module introduces a new Go library and CLI (\caveman-shrink\) that compresses MCP/OpenAI tool-definition catalogs to reduce context-window token usage. It wraps the engine's \toolschema\ compressor to drop annotation metadata and truncate long descriptions while preserving the structural selection surface (names, types, enums, required fields) and argument-construction values (defaults, constants, $ref targets) byte-for-byte. A key behavioral change is the switch to a durable, file-based CCR recovery store (defaulting to \\~/.caveman/ccr.db\ or \CAVEMAN\_CCR\_DB\), ensuring that compression handles are resolvable across separate processes, unlike the previous ephemeral in-memory approach. The tool is fail-open (passing through unchanged on errors or if compression isn't beneficial) and includes \lint\ and \recover\ subcommands for inspection and restoration.

shrink · high confidence

Security

Secure git execution with hardened config and Windows console suppression

The proxy now runs git commands through a new \gitsafe\ package that prevents untrusted repositories from executing arbitrary code via dangerous configuration knobs (such as \core.fsmonitor\, \core.hooksPath\, and \protocol.ext.allow\). It achieves this by injecting strict command-line overrides and stripping inherited \GIT\\\ environment variables, while still allowing system-level git config to remain readable. On Windows, git invocations are launched with the \CREATE\_NO\_WINDOW\ flag to prevent unwanted console windows from appearing.

proxy/internal/gitsafe · high confidence

Windows home directory permissions are now restricted to the owner

On Windows, the proxy now enforces an owner-only DACL on the CAVEMAN\_HOME directory, replacing broad access (such as 'Authenticated Users: Modify') that previously allowed other local accounts to read sensitive files like credentials. This change ensures that only the current user, SYSTEM, and Administrators can access the home folder and its contents. The restriction is applied only if the directory contains exclusively files owned by Caveman (identified by specific names and suffixes) and is not a junction, network path, or volume root; otherwise, the operation is skipped with a clear error explaining why, preventing accidental lockouts or permission corruption on shared or complex directory structures.

proxy/internal/securehome · high confidence

Architecture

Installer library restructured with new cross-platform and integration modules

The installer's internal library has been reorganized into distinct modules to improve cross-platform compatibility and integration support. A new command-argument parser (command-args.js) handles shell-agnostic argument parsing, while platform-paths.js and portable-process.js provide robust Windows command resolution and shim handling. New integration modules (cursor-native.js, openclaw.js, opencode-agent.js, provider-skills.js) manage specific host configurations, including Cursor agent setup, OpenClaw workspace integration, and Opencode agent frontmatter transformation. The owned-install.js module provides a unified ownership tracking system for file operations, and settings.js adds JSONC support with UTF-8 BOM handling for configuration files.

installer/lib · high confidence

Behavioural changes

2 commits (0 fixes) modifying dist

A change to existing behaviour in dist — 2 commits, 1 file: “chore: sync SKILL.md copies \[skip ci\]”. Also in this area: 1 commit (0 fixes) modifying dist, plugins/caveman; Improved error recovery and validation for file compression.

dist · low confidence · unverified

6 commits (2 fixes) modifying mem/js

A change to existing behaviour in mem/js — 6 commits (2 fixs), 3 files: “fix(mem): gate supersede --stdin on an advertised binary capability”; “feat: ship Caveman 2.0.0 — engine, proxy, SDKs, unified CLI”; “chore(license)!: relicense the whole repo to Apache-2.0; Caveman 3.0.0”; and 3 more.

mem/js · medium confidence · unverified

Binary installer now supports signature verification and concurrent downloads

The binary installer in packages/shared/binary-installer has been updated to pin the runtime to bin-v2.1.0 and introduce Sigstore-based signature verification for downloaded binaries, ensuring integrity via SHA-256 checksums and public key validation. Additionally, the installer now uses unique .part files for each download to prevent data corruption during concurrent installations, and includes retry logic to handle file-locking issues on Windows when replacing active daemon binaries.

packages/shared/binary-installer · high confidence

Caveman CLI v4.0.2 with native agent integration and telemetry

The CLI now automatically installs voice skills for Claude and Codex on first run and persists them via a sidecar file, ensuring they survive upgrades and disable commands. It also sends anonymous telemetry (session starts, command usage, token deltas) to a Supabase Edge Function, with an opt-out mechanism and strict privacy boundaries (no prompts, outputs, or paths uploaded). The release pins binary version bin-v4.0.2 and Blocks v0.1.0-rc.5, and includes a public key for verifying signed binary checksums.

packages/cli · high confidence

Caveman-compress skill introduces cross-platform CLI with security and reliability fixes

The caveman-compress skill now provides a standalone Python CLI that runs as a script, enabling direct execution without package context. This update adds security hardening by blocking sensitive files (such as .env, SSH keys, and credentials) from being compressed and sent to external APIs. It also fixes cross-platform reliability issues on Windows and macOS, including UTF-8 encoding handling, atomic writes to prevent data loss, and cross-session file locking to avoid concurrent modification conflicts. Additionally, the skill now correctly distinguishes between natural language and code/config files, preventing build scripts and configuration files from being incorrectly classified as compressible prose.

plugins/caveman/skills/caveman-compress/scripts · high confidence

Gemini and Vertex provider adapters: content compression, token counting, and credential routing

The Gemini adapter now supports request content compression by extracting and rewriting only the latest user-turn text and function responses, while preserving byte-identical substitutions for earlier turns to maintain cache stability. It also adds token counting support for generateContent and streamGenerateContent endpoints. Credential handling is refined to resolve Google API keys from request headers and query parameters without overriding the resolved principal, ensuring that inbound query keys do not replace or augment a selected OAuth or API-key principal. The Vertex adapter introduces publisher and model allowlists (defaulting to Google and Anthropic) with environment variable overrides, validates upstream endpoints against SSRF constraints in production, and correctly routes accounting requests for both publishers. It also ensures that Application Default Credentials (ADC) are passed through statelessly without persistence, and that inbound query keys do not alter the resolved Vertex principal.

proxy/providers/gemini, proxy/providers/vertex · high confidence

MCP server adds recovery verification and fixes protocol negotiation

The Caveman MCP server now exposes a \recovery\_verification\ capability and supports a \verify\_only\ argument on the \caveman\_retrieve\ tool, allowing hosts to check the availability and integrity (SHA-256) of a recovery handle without consuming a delivery. Additionally, the server now correctly negotiates the MCP protocol version by echoing the supported \2024-11-05\ contract instead of returning an error, preventing connection drops with hosts like Claude Code. The server also ensures recovery handles remain available after host conversation compaction by removing previous per-process repeat suppression logic.

mcp · high confidence

New contract validation scripts for schemas, fixtures, and continuous improvement reports

The contracts package now includes three new Node.js scripts to enforce data integrity before release. \validate.mjs\ performs a lightweight, fail-closed check ensuring all JSON data files in the \schemas/\ directory satisfy their sibling JSON Schema definitions. \validate-schemas.mjs\ enforces stricter structural rules: it pins schema \$id\ values to the current package version to prevent drift, ensures all \$ref\ pointers are relative, validates agent conformance fixtures against the adapter schema, checks middleware parity fixtures, and validates Protocol 1.1 examples including route-ask-v1 constraints (strict labels, cache TTLs, and model pools). \validate-continuous-improvement.mjs\ adds domain-specific validation for continuous improvement reports, verifying that themes, opportunities, relationships, motifs, and causal cases maintain internal consistency (e.g., probability calculations, unit counts, and lineage transitions).

packages/shared/contracts/scripts · high confidence

OpenAI-compatible provider now supports wire-dialect mounts for Anthropic protocol handling

The OpenAI-compatible provider adapter now supports named mounts that declare a specific wire dialect (e.g., Anthropic), enabling correct usage accounting and content compression for upstreams that deviate from the standard OpenAI shape. This change introduces a \wireDialect\ configuration that selects the appropriate usage parser and compression-zone grammar per request path, ensuring that Anthropic-specific features like \cache\_control\ breakpoints are handled correctly without breaking existing OpenAI-shape mounts. Additionally, header forwarding is now strictly scoped to mount-specific attribution headers and respects HTTP \Connection\ nominations to prevent hop-by-hop headers from leaking to upstreams.

proxy/providers/openaicompat · high confidence

Provider catalog now embedded in binary and updated with new model pricing

The provider catalog is now embedded directly into the binary via Go's embed directive, ensuring that price lookups remain consistent regardless of the working directory. This change also updates the catalog with new pricing for Anthropic's Sonnet 5.5 and Haiku 5.5, as well as OpenAI's GPT-6.1 Sol and GPT-6 Luna. Additionally, three retired models have been removed from the catalog, and the repository has been relicensed from MIT to Apache-2.0.

shared/provider-catalog · high confidence

Proxy documentation updates clarify routing, caching, and security invariants

The proxy's documentation (AGENTS.md and CLAUDE.md) has been updated to explicitly define operational invariants and behavioral rules. Key changes include clarifying that the route stage asks Cloud for the model and that runtime/v1 sender behavior is now documented, detailing the cache mechanics and the cache invariant (how cache is kept and the byte-stable replacement rules), and specifying that the proxy forwards read-only GET /v1/models instead of returning a 404. Additionally, the documentation now states that the bearer token is kept when one key arrives in both auth headers, and it discloses the proxy's prompt-cache warming behavior and its accounting.

proxy · high confidence

Python SDK introduces credential-safe transport and retry-loop protection

The Python SDK now prevents credential leakage by blocking HTTP redirects that could move credentials to another origin, and it protects agents from infinite tool-call loops by introducing a \RetryLoopBreaker\ that interrupts repeated identical calls after a configurable threshold.

caveman-sdk · high confidence

Repository restructured and relicensed to Apache-2.0 for v3.0.0

The repository has been reorganized to establish a single source of truth for skills, engine, and proxy code, with a new unified installer and consolidated documentation (CLAUDE.md, INSTALL.md). Concurrently, the project has switched its license from a split MIT/Business Source model to Apache-2.0 for all code starting with version 3.0.0, removing previous hosted-service restrictions. The diff also introduces standard repository infrastructure files including .dockerignore, .editorconfig, .gitignore, and a Dockerfile for the proxy.

(repo-wide) · high confidence

Secure binary installation with signature verification and Windows update reliability

The \mcp/bin\ and \shrink/bin\ locations now include a generated binary installer that downloads prebuilt Go binaries from GitHub releases, verifies them using Sigstore signatures and SHA-256 checksums, and installs them to the user's local bin directory. This ensures users receive authentic, untampered binaries. Additionally, the installer handles Windows-specific edge cases where long-running daemon processes lock files during updates by implementing a retry mechanism with exponential backoff, preventing installation failures and data loss when updating binaries like \caveman-proxy\ or \caveman-mcp\ while they are running.

mcp/bin, shrink/bin · high confidence

Stricter config validation and hardened proxy security defaults

The proxy now enforces stricter configuration rules and security defaults: it refuses to start if \auth\_token\ is present in \caveman.yaml\ (forcing operators to use the \CAVEMAN\_AUTH\_TOKEN\ environment variable), rejects non-loopback listen addresses unless an auth token is provided, and validates that unknown modes fail closed to 'record'. Additionally, it introduces a \wire\_dialect\ setting for OpenAI-compatible mounts to correctly parse usage accounting for non-OpenAI providers, and adds SSRF protection by allowing explicit upstream proxy configuration and custom CA bundles while ignoring unsafe forward headers.

proxy/internal/config · high confidence

Fixes

7 commits (4 fixes) fixing mem/py

A fix in mem/py — 7 commits (4 fixs), 3 files: “fix(mem): gate supersede --stdin on an advertised binary capability”; “fix(xplat): close Windows/macOS data-loss, encoding, and hook-budget gaps”; “feat: ship Caveman 2.0.0 — engine, proxy, SDKs, unified CLI”; and 4 more.

mem/py · medium confidence · unverified

New learn subcommands and proxy reliability improvements

The proxy now includes \learn experiment\, \learn export\, and \learn reconcile\ subcommands to manage A/B experiments, generate privacy-safe usage digests, and reconcile usage data. It also hardens lifecycle reliability by ensuring the proxy does not expire during idle periods and by verifying the listener generation before trusting it. Additionally, the instance identity header is now published only on loopback binds, and the native-hook bridge returns on the first complete JSON payload rather than waiting for EOF. Also in this area: 3 commits (2 fixes) fixing proxy/cmd.

proxy/cmd · medium confidence · unverified

Proper cleanup of Chrome processes on termination signals

The browse command now reliably closes Chrome and removes its temporary profile directory when it receives SIGTERM, SIGINT, or SIGHUP. A new signal-handling mechanism ensures that the main loop can be interrupted during startup or while serving, allowing deferred cleanup code to run. Platform-specific helpers handle process detachment and termination correctly on both Unix and Windows, preventing orphaned browser processes and leftover temporary files.

browse/cmd · high confidence

Test coverage

21 commits adding/updating tests in packages/middleware/typescript/tests; 37 commits adding/updating tests in packages/pi-extension/tests; Added Python middleware test suite with fail-open and adapter coverage; Added comprehensive test coverage for the Python SDK; Added comprehensive test suite for the Caveman extension; Added end-to-end middleware test suite; Added integration test for package installation and binary execution; Added integration tests for the MCP launcher and package distribution; Added release smoke test for CLI installation and wrap functionality; Added smoke tests for per-session mode state; Added test coverage for hooks subsystem; Added test for package packing and binary installation; Added tests for provider catalog validation logic; Added tests for the TypeScript SDK's assembly, context packing, OTel exporter, and middleware runtime; Installer test suite: isolated environments, agent registry validation, and host-specific integration tests; New CLI test harness and runtime fixtures for agent integration testing; New gateway tests and auth fallback logic; New test coverage for benchmarking, compression, hooks, and stats; New tests for store diagnostics, config scanning, and agent root resolution; Tests for cloudlink cache TTL, routing, and pool behavior.

Dependencies

Initial dependency manifests and lockfiles for Caveman packages

This change introduces the foundational dependency configuration for the Caveman project, adding \package.json\, \pyproject.toml\, \go.mod\, and lockfiles (\pnpm-lock.yaml\, \package-lock.json\) across multiple directories including the CLI, SDKs, middleware, browser extension, and various tools. It establishes the required runtime environments (Node.js \>=18 or \>=22.12, Python \>=3.11, Go 1.26.8) and pins specific versions for key libraries such as TypeScript 5.9.3, Playwright 1.55.0, Anthropic SDK 1.8.0, and chromedp 0.16.0, ensuring consistent and reproducible builds for all components.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 56 → 58 (+1.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 47 → 46 (-1.4)
  • Architecture 83 → 82 (-1.1)
  • Maturity 84 → 84 (+0.5)
  • Readiness 65 → 66 (+1.1)
  • Security 81 → 83 (+2.5)
  • Accessibility 54 → 61 (+7.3)
  • Performance 75 → 77 (+1.9)

Resolved (52)

  • Documentation: no licence statement (README.md)
  • Documentation: no project overview (README.md)
  • Duplicate intent with different type names. _usage.UsageReader and google._Usage have identical method signatures (feed, event, finish) and field structures (sse, decoder, text, etc.). This suggests code duplication rather than a unified usage tracking interface.
  • Duplicated block (11 lines × 2) (proxy/providers/anthropic/content_compress.go)
  • Duplicated block (12 lines × 3) (proxy/internal/store/source_claude.go)
  • Duplicated block (14 lines × 2) (proxy/internal/store/source_claude.go)
  • Duplicated block (28 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (28 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (43 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/detect.py)
  • Duplicated block (47 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/cli.py)
  • Duplicated block (5 lines × 2) (engine/compressors/relevance.go)
  • Duplicated block (51 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (57 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (6 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/validate.py)
  • Duplicated block (7 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/detect.py)
  • Duplicated block (8 lines × 2) (proxy/internal/store/source_opencode.go)
  • FileTooLong: scripts/probe-native-codex-recovery.mjs (scripts/probe-native-codex-recovery.mjs)
  • FunctionTooLong: caveman-activate.run (src/hooks/caveman-activate.js)
  • FunctionTooLong: probe-native-codex-recovery.upstream (scripts/probe-native-codex-recovery.mjs)
  • High CVE: [GHSA redacted] (packages/middleware/typescript/package.json)
  • …and 32 more

New (229)

  • CavemanPlugin.experimental.chat.system.transform (cognitive 22) (src/plugins/opencode/plugin.js)
  • Duplicated block (10 lines × 2) (mem/cmd/cavemem/main.go)
  • Duplicated block (12 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (12 lines × 3) (engine/ccr/store_integrity.go)
  • Duplicated block (12 lines × 3) (proxy/internal/store/source_claude.go)
  • Duplicated block (13 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (14 lines × 2) (engine/ccr/store_integrity.go)
  • Duplicated block (14 lines × 2) (proxy/internal/store/source_claude.go)
  • Duplicated block (16 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (29 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (31 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (5 lines × 2) (engine/compressors/relevance.go)
  • Duplicated block (55 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/cli.py)
  • Duplicated block (57 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (58 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (6 lines × 2) (proxy/internal/gateway/chatgpt.go)
  • Duplicated block (62 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/detect.py)
  • Duplicated block (67 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/compress.py)
  • Duplicated block (8 lines × 2) (plugins/caveman/skills/caveman-compress/scripts/detect.py)
  • Duplicated block (8 lines × 2) (proxy/internal/gateway/metadata_route.go)
  • …and 209 more

Changes since last survey

  • 166 commits — 83 feature/other, 83 fixes

By area

  • (repo) — 26 commits
  • packages/cli — 24 commits
  • proxy/internal — 18 commits
  • (root) — 10 commits
  • .github/workflows — 10 commits
  • engine/ccr — 8 commits
  • packages/middleware — 7 commits
  • skills/caveman-compress — 7 commits
  • agents/agents.json — 6 commits
  • installer/install.js — 4 commits
  • packages/pi-extension — 4 commits
  • src/hooks — 4 commits
  • plugins/caveman — 3 commits
  • proxy/providers — 3 commits
  • tests/installer — 3 commits
  • .github/scripts — 2 commits
  • dist/caveman.skill — 2 commits
  • docs/technical — 2 commits
  • mem/cmd — 2 commits
  • shared/provider-catalog — 2 commits

Notable commits

  • fix: Merge pull request #1395 from JuliusBrussee/daily-triage/2026-10-25-review-fixes
  • fix: Merge pull request #1478 from JuliusBrussee/fix/go-2026-6865
  • fix: Merge pull request #1500 from JuliusBrussee/fix/pi-undici
  • fix: chore: revert build-generated bin-v4.0.2 drift swept in by mistake
  • fix: fix(bench): support Anthropic SDK 2 requests
  • fix: fix(catalog): remove Vertex Gemini 2.5 rows retired 2026-10-20
  • fix: fix(cavecrew): verify subagent absence claims
  • fix: fix(ccr): apply the page cap on every store connection
  • fix: fix(ccr): count retained bytes without scanning the store on every write
  • fix: fix(ccr): free room in a full store instead of refusing every write
  • fix: fix(ccr): refuse writes to a damaged store and check it once per release
  • fix: fix(ccr): serialize writes and pin read snapshots for dedup maps
  • fix: fix(ci): select patched Go 1.26.11 toolchain (#1532)
  • fix: fix(cli): accept supersede --stdin so large replacements reach cavemem
  • fix: fix(cli): ignore managed hook object key order
  • fix: fix(cli): keep a Hermes named OAuth provider when enabling native routing
  • fix: fix(cli): pin Gemini API-key auth when routed
  • fix: fix(cli): read the proxy's top-level mode, not a nested middleware.mode
  • fix: fix(cli): require the registered MCP command to be launchable for recovery
  • fix: fix(cli): respect Hermes plugin membership config
  • …and 146 more

Architecture

  • Unchanged — 0 containers · 4 contexts · 0 edges

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

Survey your own repository

JuliusBrussee/caveman 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.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 67968b7a8ac666415a8301e1f2c86ad28567c7ec — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.