Skip to content
CAI
Software that uses CAICheck a score

ZSeven-W/openpencil

56.9

Adequate · 14 November 2026

814.3k

lines of production code

Rust

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add HTML snapshot extractor script

Added a new JavaScript asset (\snapshot-extractor.js\) that captures the visual structure of an HTML page into a JSON snapshot. The script traverses the DOM, capturing element styles (including complex properties like gradients, transforms, and stacking contexts), text content, and media, while enforcing limits on node count (40,000) and image data size (24 MiB) to ensure performance and payload manageability.

crates/op-html/assets · high confidence

Add OpenPencil VS Code extension session management and tests

This change introduces the core session management layer for the new OpenPencil VS Code extension (located in packages/op-vscode). It adds the PenSession state machine, which handles the document protocol lifecycle (booting, ready, saving, conflict resolution) via a postMessage bridge, and the SessionRegistry to track active sessions per file. Comprehensive unit tests are included for both the session logic and the registry to ensure correct behavior for init retries, state transitions, and active file tracking.

packages/op-vscode/src/session · high confidence

Add P2P collaboration smoke test binary

A new \op-collab-smoke\ binary is introduced to validate two-process peer-to-peer collaboration. It launches distinct owner and guest processes that perform a Noise XX handshake, verify signed tickets, and exchange collaboration frames over TCP. The binary includes a supervisor mode that runs a matrix of scenarios (such as alternating commits, reconnect catch-up, and epoch changes) and a LAN mode for physical-device acceptance testing, ensuring both processes converge to the same canonical document hash.

crates/op-collab-smoke · high confidence

Add per-node render-parity diff harness

Added a new script-based tooling suite in \scripts/render-parity\ to automatically compare rendered outputs between the Pencil baseline and the OpenPencil Rust implementation. The \prep\_parity.sh\ script handles the deterministic preparation of source files and renders, while \diff\_nodes.py\ performs per-node analysis using SSIM, CIE76 color difference, and bounding-box metrics to classify differences as LAYOUT, PAINT, or PASS, generating a detailed JSON and Markdown report.

scripts/render-parity · high confidence

Added G3 A/B testing harness for design generation agents

Introduced a new shell script at scripts/ab-g3/run.sh that executes an A/B comparison between the built-in agent loop and a single-shot orchestrator for OpenPencil design generation. The harness runs a defined corpus of 15 prompts across various contexts (dashboards, mobile apps, landing pages) against specified models (defaulting to glm-5.2, with optional OpenAI-compatible strong models), capturing results and gaps in a configurable output directory to facilitate audit and performance analysis.

scripts/ab-g3 · high confidence

Added build and type-generation tooling for the op-web-sdk crate

The op-web-sdk crate now includes local build scripts to manage its WebAssembly bundle and TypeScript bindings. The new build-wasm.sh script automates the compilation of the SDK to wasm32, runs wasm-bindgen, and enforces a 6 MiB gzip size limit to prevent bundle bloat, while also verifying that the resulting binary has no environment imports. Additionally, gen-types.sh generates TypeScript type definitions from the jian-ops-schema and places them in the crate's bindings directory, ensuring the vendor submodule remains clean after generation.

crates/op-web-sdk/tools · high confidence

Added headless relay reconnect probe example

A new \relay\_probe.rs\ example has been added to the \op-collab-host\ crate to allow headless testing of the public-relay reconnect loop. This tool drives the \CollabRuntime\ without a GUI, enabling an owner and a guest to meet over the real relay using a shared invite file, which is useful for verifying connection stability and reconnection behavior in isolated test environments.

crates/op-collab-host/examples · high confidence

Added local ACP test agent fixture for E2E validation

A new example agent (\op-acp-test-agent.rs\) has been added to support end-to-end testing of the desktop local-process transport. This fixture listens on standard input for JSON-RPC frames, validates initialization and session parameters against strict ndJSON expectations, and returns predefined responses. It allows the desktop application to exercise the production stdio transport with a controlled, deterministic agent during testing.

crates/op-host-desktop/examples · high confidence

Added script to bake scene template preview cards for the editor UI

A new Python script (\scene\_preview\_cards.py\) has been added to generate optimized 16:10 JPEG preview images for the Scene Template Center. This tool processes source renders into standardized thumbnails that fit the gallery's card layout, handling multi-frame templates by tiling them and long-form designs by preserving key visual sections, ensuring consistent and recognizable previews in the editor's asset center.

python · high confidence

Added vision-based design QA validation skill

A new validation phase skill has been introduced that performs quality assurance on UI designs by analyzing screenshots alongside their underlying node tree structures. This skill automatically detects and proposes fixes for visual issues such as width inconsistencies, spacing errors, text clipping, alignment problems, and missing elements, while also providing a quality score. It includes specific logic to distinguish between rendering defects and intentional design patterns, such as horizontal scrollers and chart marks, ensuring that valid layouts are not incorrectly flagged.

crates/op-ai-skills/skills/phases/validation · high confidence

Android JNI engine bindings and native mobile infrastructure

This change introduces the Android JNI layer for the OpenPencil engine, providing the native bridge required for mobile operation. It includes a dedicated engine thread for safe FFI dispatch, a handle registry to manage engine lifecycles, and specific bindings for editor features (sign-in, account center, locale, and export), text input (IME and caret management), and media handling (remote images and fonts). The implementation also adds Android-specific logging via logcat and native window management for the rendering surface.

crates/op-engine-jni · high confidence

Bundled OpenPencil design skill with CLI reference and codegen pipeline

The CLI now ships with a bundled design skill (installed to the scanned skills directory) that provides a comprehensive reference for the OpenPencil design system, including the PenNode schema, semantic roles, layout rules, and common UI patterns. This skill exposes the full codegen pipeline (plan, submit, assemble, clean) and layered workflow (skeleton, content, refine) to AI agents, and includes a \skill:export\ command to package these assets for external use.

crates/op-cli · high confidence

Chrome extension core adds account integration, design system extraction, and delivery targets

The \op-chrome-extension-core\ crate introduces the foundational logic for the new OpenPencil Chrome extension. It adds account management (account.rs) supporting dual-region Hub origins (China and Global) with a public-client authentication flow, and delivery routing (delivery.rs) that allows signed-in users to send captures to their Hub account or the local editor. It also implements intelligent design system extraction (design\_md.rs, design\_md\_job.rs, design\_md\_palette.rs, design\_md\_render.rs) which parses browser evidence into deterministic Markdown and handles async job polling for LLM-enhanced output.

crates/op-chrome-extension-core · high confidence

Complete i18n coverage across menus, providers, and panels

The op-i18n crate now provides full localization support for 15 locales (including German, Chinese, Japanese, and others) across the entire application. This update introduces comprehensive translation catalogs for core UI elements, the new prompt center, scene templates, and collaboration features, ensuring a consistent localized experience for users across all panels and providers.

crates/op-i18n · high confidence

Generated TypeScript bindings for OpenPencil SDK

The \crates/op-web-sdk/bindings/ops.ts\ file has been added, providing the generated TypeScript type definitions for the OpenPencil SDK. This file, produced by ts-rs, exposes core types such as Action, AppConfig, and various UI node definitions (e.g., CheckboxNode, EllipseNode), enabling TypeScript consumers to interact with the SDK's API surface with proper type safety.

crates/op-web-sdk/bindings · high confidence

Headless agentic loop smoke testing and model discovery

The smoke testing harness now supports a headless agentic tool-loop mode (OPENPENCIL\_SMOKE\_LOOP) that exercises the design agent's iterative tool-calling against a live EditorState, including a minimal scaffold seed path for weak models. It adds a best-of-N candidate selection mechanism (OPENPENCIL\_SMOKE\_BEST\_OF) to score and pick the highest-quality generation, and introduces a post-loop image-fill step (OPENPENCIL\_SMOKE\_FILL\_IMAGES) to resolve image-search queries using an optional vision judge. A new audit rubric (OPENPENCIL\_SMOKE\_AUDIT) provides deterministic metrics for chrome completeness, vocabulary richness, interactivity, and content completeness. Additionally, a new op-builtin-model-discovery crate enables runtime discovery of model catalogs from configured providers with bounded, secure HTTP requests. Also in this area: Headless smoke client now retries on provider 429 rate limits.

crates/op-smoke/src · high confidence

Initial release of OpenPencil for VS Code

This change introduces the OpenPencil VS Code extension, enabling users to open, view, and edit \.op\ design files directly within the editor via a custom webview backed by a local daemon. Key capabilities include live preview, managed account login, LAN/public-relay collaboration, \.fig\ file import, and AI-driven code generation for React or Vue. The extension also integrates with AI tooling through a local MCP proxy, allows installation of design skills, and provides a \@openpencil\ chat participant, all while respecting workspace trust settings.

packages/op-vscode · high confidence

Introduce @zseven-w/op-web-sdk for read-only document viewing

The \packages/op-web-sdk\ package is now available as a read-only web SDK for OpenPencil \.op\ files, backed by a Rust/WASM renderer. It provides a \createViewer\ API that binds to an HTML canvas, allowing users to load documents, inspect metadata (document name, page count), control the viewport (pan, zoom, fit), and export the current view to SVG. The SDK intentionally excludes editing capabilities (node creation, selection, or property panels) and includes a demo page and a comprehensive test suite to verify event handling, navigation, and schema compatibility.

packages/op-web-sdk · high confidence

Introduce Agent Client Protocol (ACP) client for third-party agent integration

Added the \op-acp\ crate, a Rust implementation of the Agent Client Protocol that allows third-party AI agents to integrate with OpenPencil. The client supports both local agents (spawned as child processes over stdio) and remote agents (connected via WebSocket), handling the full JSON-RPC 2.0 handshake, session management, and streaming updates. It includes robust process lifecycle management with bounded retries for transient \ETXTBSY\ errors on Linux/macOS, and maps agent notifications into the application's chat delta vocabulary for display.

crates/op-acp · high confidence

Introduce OpenPencil VS Code extension with AI code generation and MCP configuration

This change adds the \op-vscode\ extension, providing a custom editor for \.op\ design files and a \.fig\ import workflow that converts Figma designs to the OpenPencil format. It introduces a 'Generate Code' command that uses the VS Code Language Model API to create React or Vue components from designs, with strict validation to prevent path traversal and size-limit violations. Additionally, it adds commands to configure and remove MCP (Model Context Protocol) settings for AI agents, including a diff-preview before writing, and registers a read-only 'OpenPencil' chat participant for design advice.

packages/op-vscode/src/vscode · high confidence

Introduce OpenPencil Web Capture Chrome extension

Adds a new Chrome extension that captures the rendered state of web pages and imports them as editable design nodes into OpenPencil, or extracts a reusable design-system summary (design.md). The extension runs a Rust logic core compiled to WebAssembly and provides four actions: capturing the full page, capturing a specific element, downloading a ready-to-open .op file, and extracting design.md evidence. It supports account-based uploads to the OpenPencil hub with fallback to the local desktop app, handles internationalization for multiple languages, and enforces strict security policies including loopback-only communication and content security constraints for WebAssembly.

packages/op-chrome-extension · high confidence

Introduce React and Vue adapters for the OpenPencil read-only web viewer

This change adds two new framework-specific packages, \@zseven-w/op-web-sdk-react\ and \@zseven-w/op-web-sdk-vue\, which wrap the core \@zseven-w/op-web-sdk\ to enable embedding the read-only design canvas in React 19 and Vue 3 applications. The React adapter provides a \DesignView\ component and hooks (\useDocument\, \useViewport\, \useActivePage\) that use \useSyncExternalStore\ to efficiently sync viewer state with React's render loop. The Vue adapter offers a \DesignView\ component and composables (\useDocument\, \useViewport\, \useActivePage\) that leverage Vue's reactivity system to update views on viewer events. Both adapters handle the asynchronous loading of the underlying WebAssembly binary and provide a \DesignProvider\/\provideViewer\ mechanism for advanced layouts.

packages/op-web-sdk-react · high confidence

Introduce Rust-native batch\_design tool with lenient model-input normalization

The \op-mcp\ crate now includes a Rust implementation of the \batch\_design\ tool, enabling atomic insertion of node forests via an \operations\ DSL (e.g., \I(parent, node)\), \nodes\_json\, or a sandboxed \script\ input. To accommodate imperfect model outputs, the tool applies lenient normalization: it maps Figma/Pencil dialects (like \layoutMode\ to \layout\), flattens structured layout objects, normalizes fill type names (e.g., \linear-gradient\ to \linear\_gradient\), and repairs gradient stop fields (\pos\ to \offset\). The tool predicts host-assigned node IDs in its response to match TypeScript behavior and ensures transactional integrity by rejecting batches on any single validation error.

crates/op-mcp · high confidence

Introduce Unix-only HSM-backed relay locator signer

Added a new \op-collab-relay-locator-hsm\ crate that provides a PKCS\#11-backed daemon for signing relay locators. This component is strictly limited to Unix platforms, relying on POSIX-specific security guarantees such as Unix-domain socket peer credential authentication (\SO\_PEERCRED\/\getpeereid\), strict file ownership and permission checks for configuration and PIN files, and exclusive file locking. It manages an isolated PKCS\#11 token to store Ed25519 key pairs, supporting key provisioning, readiness canaries, and the signing of canonical locator payloads via a dedicated binary interface.

crates/op-collab-relay-locator-hsm · high confidence

Introduce centralized account state and agent settings models in editor core

The editor core now owns the plain-data models for user authentication and AI agent configuration, moving them out of host-specific UI layers. A new \AccountState\ enum tracks signed-in status and profile display details, while \AgentSettings\ and its sub-modules (\config\_types\, \mutators\, \acp\_connection\) define the structure for built-in agents, ACP connections, image-generation profiles, and MCP CLI toggles. This centralization provides a single source of truth for account and agent state that is platform-agnostic and ready for host integration.

crates/op-editor-core/src · high confidence

Introduce headless op-host-web-server binary

A new headless binary, op-host-web-server, is available to run the OpenPencil web and MCP server without any GUI dependencies. It delegates command-line mode handling to op-host-services and supports three modes: --serve-web for the headless web-canvas daemon, --mcp for a JSON-RPC stdio MCP server, and --mcp-http for a Streamable-HTTP MCP server. This allows container or server images to remain GUI-free while providing the same dispatch logic as the desktop binary.

crates/op-host-web-server/src · high confidence

Introduce host-free ACP agent probe and web AI proxy services

The \op-host-services\ crate now hosts the core logic for ACP agent connection probing and the web AI proxy, previously located in desktop-specific modules. The new \acp\_agent\_probe\_host.rs\ provides a platform-agnostic probe job that validates agent connectivity and session lifecycle, while \ai\_proxy.rs\ implements the backend proxy for the WASM web bundle, handling structured model routing, skill expansion, and SSE streaming. Additionally, \chat\_attachment.rs\ moves attachment handling (base64 encoding and temp-file spilling) to this shared location to support both CLI and web transports.

crates/op-host-services/src · high confidence

Introduce op-collab crate for deterministic, resource-bounded document collaboration

The new \op-collab\ crate provides the core logic for OpenPencil's peer-to-peer collaboration, handling versioned wire DTOs, deterministic document hashing, and exact atomic operations on the \PenDocument\ schema. It enforces strict resource limits—such as maximum operations per transaction, subtree size, tree depth, and validation visits—to prevent resource exhaustion during document edits. The crate supports a specific M1 edit matrix, allowing property changes (like text content, opacity, or layout) and structural changes (inserting, deleting, or moving basic nodes like frames and rectangles) while rejecting unsupported fields or complex mixed edits. It also manages session state, including owner/guest roles, namespace-scoped ID counters, and replay verification to ensure that generated collaboration transactions deterministically reproduce the target document state.

crates/op-collab · high confidence

Introduce public WebSocket relay client for collaboration

The \op-collab-relay-client\ crate is now available, providing a native relay data-plane client that adapts the existing loopback TCP collaboration transport to a public WebSocket relay. This client bridges local TCP connections to a remote relay endpoint without terminating or inspecting the inner Noise session, supporting both guest and owner roles with bounded lifetimes and strict authentication via a caller-owned \RelayAuthenticator\. It enforces security by requiring \wss://\ in production, capping bearer credentials, and pinning relay public keys, while offering reduced-assurance compatibility modes for specific relay configurations.

crates/op-collab-relay-client · high confidence

Introduce public collaboration relay protocol with challenge-bound authentication and short pairing codes

This crate defines the wire protocol for OpenPencil's public collaboration relay, enabling users to connect via short, 10-character region-tagged pairing codes instead of long invite strings. The protocol introduces a new authentication mode (v2) that replaces reusable possession attestations with relay challenges bound to the caller's X25519 shared secret, enhancing security. It also supports a v2 sealed pairing invite envelope using ChaCha20-Poly1305, while maintaining backward compatibility with legacy v1 envelopes during rollout. The protocol specifies fixed-size binary formats for locators, invites, and client hellos, along with waiting-window advertisements to manage unpaired peer lanes.

crates/op-collab-relay-protocol · high confidence

Introduce public collaboration relay server with hardened authentication and connection management

This change adds the \op-collab-relay-server\ crate, providing the server-side implementation for public peer-to-peer collaboration. The relay enforces strict authentication via X25519 challenge-response proofs and bearer credentials, supporting production modes with pinned trust roots and reduced-assurance ticket binding. It manages connection lifecycles with configurable timeouts for waiting, idle, and tunnel lifetime, and includes a lease mechanism to keep unpaired owner lanes alive. Connection teardown is hardened to prevent RST-induced data loss by using a bounded linger period and embedding rejection reasons in WebSocket close frames. The server exposes configuration via environment variables and command-line flags for production, development, and health-check modes.

crates/op-collab-relay-server · high confidence

Introduce public relay collaboration with region-tagged pairing codes and hardened control-plane logic

This crate adds the control-plane core for public relay collaboration, replacing the previous public-invite model with a pairing-code flow (publish and claim endpoints) that uses 10-char region-tagged codes to exchange sealed invites. It introduces a hardened HTTP client that enforces HTTPS-only, disables redirects and proxies, applies bounded connect/request timeouts and response-size limits, and redacts sensitive data in debug output. The locator-issuance service now classifies control-plane failures (unauthorized, rate-limited, rejected) so clients can distinguish authentication issues from temporary service pressure, and it binds collaboration tickets to the owner's device DH key before delegating signing to an external HSM/KMS via the RelayLocatorSigner trait. The pairing service enforces per-owner quotas, TTL clamping, and idempotent storage, while wire formats for pairing and locator requests are strictly bounded and version-checked.

crates/op-collab-relay-control-plane · high confidence

Introduce read-only web viewer SDK with pan/zoom, SVG export, and smoke test

The \op-web-sdk\ crate now provides a read-only viewer for embedding OpenPencil documents in the browser. Users can load \.op\ JSON documents, navigate via pan/zoom (including wheel and pinch-to-zoom support), and export the active page to SVG. The SDK includes a robust render loop that idles when clean and handles failure states gracefully, along with a smoke test page to verify basic functionality.

crates/op-web-sdk/src · high confidence

Introduce relay locator server with hardened trust roots and resource limits

The relay locator server now ships with a new \op-collab-policy-file\ crate that enforces strict security checks on pinned verification key files, rejecting symlinks, foreign ownership, and group/world-writable permissions to prevent trust-root tampering. The server itself includes a bounded in-memory pairing store that caps total codes and per-owner limits to prevent squatting, and implements fixed-window rate limiting with both global and per-client ceilings to protect against resource exhaustion. Configuration is validated to ensure timeouts and concurrency limits are sensible, and Unix-specific HSM signing is isolated behind platform gates.

crates/op-collab-relay-locator-server · high confidence

Introduce shared OpenPencil config store with sandboxed mobile support

A new \op-config-store\ crate provides a unified, file-backed configuration system for the application. On desktop, it defaults to the \\~/.openpencil\ directory, while embedded mobile hosts can explicitly configure a private app-sandbox root via \configure\_user\_root\ to ensure settings are isolated from the desktop environment. The store supports atomic JSON read/write operations and includes a test-specific \redirect\_user\_root\_for\_tests\ helper to prevent parallel tests from modifying live user configuration files.

crates/op-config-store · high confidence

Introduces managed daemon lifecycle, HTTP client, and pooling for the VS Code extension

The \op-vscode\ extension now manages a background \op-host-web-server\ daemon process to handle document operations. This change adds a \DaemonClient\ that spawns the daemon, performs a secure handshake (redacting tokens from logs), and handles graceful shutdown. A \DaemonHttp\ client provides token-authenticated access to the daemon's endpoints, including a new \figmaConvert\ API for converting \.fig\ files to \.op\ format. A \DaemonPool\ manages one daemon per open file, handling concurrent access, crash recovery (single restart), and active-file routing. Comprehensive unit tests verify the handshake, security, HTTP interactions, and pool lifecycle.

packages/op-vscode/src/daemon · high confidence

Introduces secure, authenticated collaboration transport with resource protection

The collaboration transport now requires authenticated admission via signed tickets, binding device identity and optional profile data (display name, avatar) to each connection. To prevent resource exhaustion, the transport enforces strict limits on pending handshakes (128 global, 4 per IP), active connections (64), and inbound reassembly buffers (128 MB aggregate), while chunked transfers are capped by class (Control, Ticket, Txn, Snapshot) with dedicated timeouts. Platform-specific secure storage (e.g., iOS Keychain with ThisDeviceOnly accessibility) protects the X25519 device identity, and the admission layer validates ticket signatures, issuer/subject/device UUIDs, expiry, and profile constraints, failing closed on malformed or expired claims.

crates/op-collab-transport/src · high confidence

Introduces the op-ai-skills crate for phase-driven prompt skill resolution

A new Rust crate, \op-ai-skills\, has been added to replace the previous TypeScript implementation for managing AI design skills. This engine handles the full lifecycle of prompt construction: it loads a verbatim markdown corpus of skills and style guides, filters them by phase (planning, generation, validation, maintenance), matches them against user intent via keywords or flags, and injects design context. Crucially, it enforces a strict token budget by capping individual skills and filling the remaining space by category priority (Base, Domain, Knowledge), ensuring that critical protocol skills are never truncated. The crate also provides built-in design system presets (halo, lunaris, nitro, shadcn) and exposes a guideline API for topics like web-app, mobile, and slides, all while remaining dependency-minimal and compatible with wasm32 targets.

crates/op-ai-skills/src · high confidence

Introduction of op-auth-bridge with ABI v3 support and strict provenance validation

The new op-auth-bridge crate establishes the boundary for OpenPencil's authentication and collaboration ticket verification. It integrates prebuilt, proprietary op-auth libraries (ABI v3) for ten desktop and mobile targets, enforcing strict provenance checks via Ed25519 signatures and SHA-256 digests to prevent replay attacks. The build system now validates these artifacts, isolates bundled Rust runtime symbols to avoid linker conflicts, and supports local development overrides for ABI v2 and v3 archives. Additionally, it configures regional login and collaboration trust through environment variables like OPENPENCIL\_SSO\_URL and OPENPENCIL\_COLLAB\_ISSUER, ensuring that collaboration policies are verified against a pinned offline root.

crates/op-auth-bridge · high confidence

MCP proxy and config adapters for multi-IDE support

The extension now includes a local MCP proxy that routes requests to the active document's daemon, enforcing security by rejecting non-POST methods on /mcp (returning 405), blocking requests with Origin or mismatched Host headers (returning 403), and echoing JSON-RPC errors when no document is active. It also introduces per-IDE MCP configuration adapters that detect the editor (VS Code, Cursor, Trae, Windsurf) and write typed HTTP server entries to the correct config file path while preserving existing comments and sibling fields.

packages/op-vscode/src/mcp · high confidence

MCP session auto-finalization and headless design agent capabilities

The MCP serve module now includes an auto-finalization system for file-backed sessions that automatically runs the design pipeline and saves the document when the session has been idle for a configurable period (default 45 seconds) or upon shutdown, with the behavior controlled by the OPENPENCIL\_MCP\_AUTO\_FINALIZE and OPENPENCIL\_MCP\_AUTO\_FINALIZE\_IDLE\_SECS environment variables. A new headless design agent tool (run\_design\_agent) allows the MCP to execute a full design loop against the active document using configured builtin AI providers, with structured error handling for missing providers, timeouts, and empty results. Additional tools expose design quality scanning (get\_design\_quality), image enrichment (enrich\_images), and code generation workflows (codegen\_plan, codegen\_submit\_chunk, codegen\_assemble, codegen\_clean), while document sync helpers provide REST API parity for whole-document synchronization.

_crates/op-host-services/src/mcp\serve · high confidence

Native macOS window chrome, localization, and hardened runtime entitlements

The desktop host now ships with a native \Info.plist\ and \entitlements.plist\ for the macOS bundle. The app supports a wide range of localizations (en, zh-Hans, zh-Hant, ja, ko, fr, es, de, pt, ru, hi, tr, th, vi, id) and uses the user's preferred language for native system panels. To allow the binary to link against Homebrew OpenSSL dylibs under the hardened runtime, the \com.apple.security.cs.disable-library-validation\ entitlement is enabled. Additionally, the app declares local network usage for collaboration discovery via Bonjour.

crates/op-host-desktop/src · high confidence

Native mobile account center and new social sign-in providers on Android

The Android app now includes a native, full-screen account center overlay that displays the user's profile (display name, email) and allows them to manage their region, open the web account page, or sign out. Additionally, native sign-in flows for Douyin and Alipay have been added, integrating their respective SDKs to handle authorization and code exchange, expanding the available social login options on Android.

app · high confidence

New AI Support Pitch Deck presentation template

A new six-page presentation template named 'ai-support-pitch-deck' is now available in the scene template library. Designed for pitching an autonomous customer service AI product, it includes structured slides for the cover, pain points, market trends, solution pillars, product workflow, key metrics, a customer case study, roadmap, team, and funding request, providing a ready-made narrative structure for sales and investor decks.

_crates/op-editor-core/assets/scene\templates · high confidence

New AI skill knowledge base for code generation and design conversion

Added a new knowledge directory to the op-ai-skills crate containing structured markdown guides for the AI agent. This includes a 'code-to-design' skill for reverse-engineering existing frontend codebases into OpenPencil designs, and specific code generation rules for multiple frameworks including React, React Native, Flutter, Jetpack Compose, SwiftUI, Vue, Svelte, and plain HTML/CSS. The knowledge base also provides guidelines for component composition, design system hierarchy, copywriting, and general design principles to ensure consistent and high-quality output.

crates/op-ai-skills/skills/knowledge · high confidence

New CSS cascade engine with UA defaults and media query support

The HTML importer now includes a dedicated CSS cascade implementation in the \op-html\ crate. This engine parses stylesheets, resolves the cascade (including specificity, origin, and layering), and applies a built-in User Agent stylesheet that defines default styles for common HTML elements like headings, paragraphs, and tables. It also supports \@media\ queries for viewport-based styling and handles CSS logical properties (such as \margin-inline-start\) by mapping them to physical properties based on text direction.

crates/op-html/src/css · high confidence

New HTML importer crate with CSS parsing and encoding support

The \op-html\ crate introduces a new HTML import pipeline that parses HTML5 DOMs into a simplified tree structure and handles CSS color and length unit parsing. It includes robust encoding sniffing for both HTML and CSS byte streams, supporting BOM detection, \@charset\ rules, and Windows-1252 fallbacks to ensure legacy stylesheets render correctly. The importer also extracts \@font-face\ declarations to warn users when web fonts are not downloaded, and includes comprehensive end-to-end tests for layout fidelity, including Tailwind CSS grid/flex behavior, list markers, and responsive image selection. Also in this area: Fix zip archive name extraction and update zstd decoder API.

crates/op-html/src · high confidence

New HarmonyOS player shell for phone, tablet, and 2-in-1 devices

This change introduces the complete packaging skeleton for the OpenPencil HarmonyOS player, enabling the app to run on HarmonyOS 5 (API 12+) across phone, tablet, and 2-in-1 form factors. The entry module wires the prebuilt Rust NAPI engine (\libopenpencil.so\) into an ArkUI shell that renders the UI via an \XComponent\ surface. It includes the native sign-in SDKs for WeChat, Alipay, and Douyin, implements the full editor input pipeline (IME, pointer events, and keyboard handling), and supports system file pickers for opening, saving, and importing documents. The shell also handles desktop-class features like mouse input, hardware key modifiers, and background generation tasks for AI services.

packaging/harmony/entry · high confidence

New Rust-based Figma import engine

The \op-figma\ crate introduces a complete Rust implementation for importing Figma designs, replacing the previous TypeScript-based logic. This change adds support for parsing the native binary \.fig\ Kiwi format (including Zstandard/deflate decompression and ZIP archive handling), decoding Figma HTML clipboard payloads, and converting Figma node trees into the internal \PenNode\ schema. It also implements specific rendering behaviors for boolean operations, component property swaps, and icon lookups, along with comprehensive end-to-end and unit tests for the new pipeline.

crates/op-figma/src · high confidence

New Rust-based code generation crate for HTML, CSS variables, and framework targets

The \op-codegen\ crate introduces a Rust implementation of the design-to-code pipeline, starting with a CSS variables generator that emits scoped custom properties (including shadcn-compatible dark-mode blocks) and an HTML generator that produces absolutely positioned markup with inline styles and document-level motion declarations (transitions, keyframe animations, and reduced-motion support). The crate also scaffolds the architecture for additional framework targets (React, Vue, Svelte, Flutter, SwiftUI, Compose, React Native) via a shared \Codegen\ trait, and maps first-class design widgets (inputs, selects, radio groups, switches, checkboxes, sliders, progress, and tabs) to their corresponding HTML form elements. Also in this area: AI code generation pipeline ported to Rust.

crates/op-codegen · high confidence

New Rust-based document loader and layout adapter

The \op-pen-loader\ crate now provides the canonical Rust implementation for loading \.op\ and \.pen\ documents into the desktop editor. It bridges the \jian-ops-schema\ \PenDocument\ into the editor's \DocPayload\ by delegating flex layout to \jian-core\'s \LayoutEngine\ (using a Skia-backed measure cache for accurate text sizing) and mapping all 12 node variants into \NodePayload\ structures with computed absolute coordinates. The loader supports both standard layout resolution and a 'preserve geometry' mode for Figma imports, and includes specific handling for active-page scene building, legacy component references, and canvas preview parity.

crates/op-pen-loader/src · high confidence

New account management widgets and sign-in flow

The editor now includes dedicated widgets for account management, including an avatar painter that overlays the user's profile image on initials, a press-flow handler for the sign-in modal and account dropdown, and a settings panel tab for signing in, signing out, and viewing account details. These components centralize the account UI logic and integrate with the existing settings and top-bar interfaces.

crates/op-editor-ui/src/widgets · high confidence

New build and release automation scripts for Android, macOS, Windows, and OpenHarmony

This change introduces a suite of new shell and PowerShell scripts in the \scripts/\ directory to standardize and secure the build, packaging, and installation processes across platforms. For Android, \android-version.sh\ derives a stable \versionCode\ from the Rust workspace SemVer, while \build-android-release.sh\ orchestrates the build using pinned SDK/NDK versions and verified Skia binaries. macOS packaging is handled by \bundle-macos.sh\, which generates the \.app\ bundle and correctly registers \.fig\ file associations via UTI declarations. Windows installation is automated via \install-op.ps1\, which resolves the latest release, verifies checksums, and installs the required Visual C++ runtime. A cross-platform \install-op.sh\ script provides similar CLI installation for macOS and Linux. Additionally, \build-ohos.sh\ and its associated toolchain wrappers enable cross-compilation for OpenHarmony, including necessary patches to the Skia build system.

scripts · high confidence

New build scripts for icon catalog generation and SDK version synchronization

Added \generate-iconify-catalog.mjs\ to extract and split icon data from Lucide, Feather, and Simple Icons into core and brand JSON catalogs for the editor UI, and introduced \sync-version.mjs\ to keep package versions consistent across root and SDK manifests, TypeScript entry points, and the Bun lockfile using TypeScript AST parsing and JSONC comment support.

packages/scripts · high confidence

New color system with WCAG contrast checking and design palettes

The \op-ai-skills\ crate now includes a new color module that provides a design style-resolution system. It introduces a palette engine supporting seven named themes (such as 'Alloy Blue' and 'Amber Field') in both light and dark modes, mapping semantic roles like \surface.primary\ and \accent.primary\ to specific colors. The system uses OKLCH color space for generating 12-step neutral and accent scales. Additionally, it adds WCAG-compliant contrast checking utilities, including a function to automatically determine appropriate foreground text colors for a given background and a scanner to flag color pairs that fail accessibility contrast targets.

crates/op-ai-skills/src/color · high confidence

New daemon-side collaboration service for the web canvas

The web canvas server now supports real-time collaboration through a new daemon-side service exposed via \/api/collab/\*\ routes. A dedicated background driver thread pumps the collaboration runtime, handling session state, presence updates, and UI actions without blocking the REST API. Clients can query the current projection state, enqueue UI actions (with conflict detection for concurrent requests), and publish local cursor presence. The implementation includes strict security gates for online deployments (refusing LAN-discovery actions from untrusted origins) and separates document versioning from projection sequencing to prevent unnecessary browser refetches on cursor movements.

_crates/op-host-services/src/web\_canvas\server · high confidence

New declarative Nix integration surface for OpenPencil

The Nix flake now exports a versioned integration contract (OpenPencil.pkl) and a generated Nix sidecar (openpencil.nix) that downstream flakes can consume to access OpenPencil's package outputs (runtime, web-server, skills), executables (desktop, CLI), and MCP transport configurations. The integration surface defines adapters for various AI harnesses (Claude, Codex, Gemini, etc.) and includes a Skillnet manifest for the design skill, providing a standardized way to integrate OpenPencil into Nix-based environments without duplicating configuration details.

nix · high confidence

New design-lint detectors for empty panels, motion budgets, shader costs, and AI-generated patterns

The \op-design-lint\ Rust crate now includes a suite of new diagnostic detectors that analyze design documents for structural and performance issues. The \empty\_filled\_panel\ detector flags large, solid-filled containers that lack child content, helping identify accidental blank space. Motion budget checks warn when a document exceeds 32 animated nodes, when animation durations surpass the 1500 ms Material 3 ceiling, or when non-whitelisted motion properties are used. Shader budget analysis identifies invalid SkSL fills (such as incorrect uniform arities or unknown presets) and warns when full-bleed shader fills exceed platform-specific budgets (2 for mobile, 4 for desktop). Additionally, sibling consistency detectors now enforce stricter rules for corner radius and padding among same-kind elements, while new "slop" detectors warn against common AI-generated design patterns like purple-glow gradients, generic three-card feature rows, and excessive rounded-card walls.

crates/op-design-lint/src/detectors · high confidence

New diagnostic and benchmark examples for Figma import pipeline

Added a suite of command-line examples in \crates/op-figma/examples\ to support debugging, performance profiling, and validation of the Figma import pipeline. \bench\_memory\ and \bench\_prepared\ provide memory allocation tracking and stage-by-stage timing for binary \.fig\ imports. \probe\_fig\, \probe\_frame\, \probe\_icons\, \probe\_layout\, \probe\_vec\, and \probe\_vn\ serve as diagnostic tools to inspect raw Kiwi fields, node geometry, vector network blobs, and layout conversions. Additionally, \split\_op\_pages\ allows extracting individual pages from multi-page \.op\ documents.

crates/op-figma/examples · high confidence

New domain-specific design skill contracts for AI generation

The \op-ai-skills\ crate now includes a set of domain-specific design contracts in \skills/domains\ that guide the AI agent's generation behavior for specific UI contexts. These new markdown files define strict structural, typographic, and layout rules for Cards (portrait formats like XHS), CJK Typography (language consistency, font pairing, and line-breaking taboos), Dashboards (compact density, metric rows, and data table hierarchy), Decks (narrative arcs, density budgets, and page-type routing), Deck Patterns (slide skeletons and chart geometry), Form UI (input/button sizing and paired control alignment), Landing Pages (conversion-driven section flow and rhythm), Logo Concepts (structural fusion operations and validation tests), and Mobile Apps (three-section architecture with status bar and bottom navigation handling). These contracts ensure consistent, high-fidelity output by enforcing hard rules on spacing, typography, and component composition for each domain.

crates/op-ai-skills/skills/domains · high confidence

New generation-phase skills for code assembly, layout, and interactivity

The \crates/op-ai-skills/skills/phases/generation\ directory now contains a comprehensive set of prompt-skill definitions that guide the AI model during the design-to-code generation phase. These new files establish strict rules for code assembly (deduplicating imports, composing root components, and handling degraded chunks), chunk planning (splitting PenNode trees into disjoint semantic sections), and layout (enforcing flexbox-based positioning, preventing overflow, and managing mobile-specific constraints like content rails and bottom navigation). The update also introduces skills for interactivity (defining state schemas, bindings, and event handlers for multi-screen navigation), visual diversity (preventing generic 'AI slop' aesthetics), and first-class interactive widgets (requiring native control types with explicit design-system styling).

crates/op-ai-skills/skills/phases/generation · high confidence

New host-core modules for code generation, chat, and collaboration

The \op-editor-host-core\ crate now includes dedicated modules for code generation (\codegen\, \codegen\_session\, \codegen\_runtime\_state\, \codegen\_export\), chat (\chat\), and collaboration (\collab\). The codegen module introduces a background worker pipeline that builds input from the editor state, manages session lifecycles with cancellation and stale-session retirement, and produces downloadable artifacts (source files or ZIP bundles) with strict size limits. The chat module provides a shared worker and transcript folding logic, including a tool executor that forwards calls to the host UI thread. The collaboration module adds transport-neutral guest and owner editor sessions, handling document installation, local edits, and frame queuing with configurable limits. Also in this area: Fix zip archive name extraction and update zstd decoder API.

crates/op-editor-host-core/src · high confidence

New op-editor-ui crate with accessibility, avatar, and SVG export capabilities

The editor UI has been extracted into a new \op-editor-ui\ crate, providing a platform-agnostic widget facade for both native and web hosts. This change introduces a complete accessibility tree assembler (\accessibility.rs\ and \accessibility\_regions.rs\) that maps editor regions to screen-reader nodes, ensuring the UI is navigable by VoiceOver, Narrator, and Orca. It also adds a runtime for fetching and caching authenticated collaboration avatars (\collab\_avatar\_runtime.rs\) with SSRF-safe handling and LRU eviction, and a new SVG export module (\svg\_export.rs\) that serializes the active page or selected nodes with canvas-parity, including support for gradients, image fills, and ancestor clipping.

crates/op-editor-ui/src · high confidence

New op-util crate consolidates shared utilities

The new \op-util\ crate introduces a set of dependency-free, cross-platform utilities that replace previously copy-pasted implementations across the codebase. It provides a canonical hex-color parser supporting \\#RGB\, \\#RGBA\, \\#RRGGBB\, and \\#RRGGBBAA\ formats with configurable strictness, and a lightweight image dimension reader that extracts intrinsic sizes from PNG, JPEG, GIF, WebP, and SVG headers without requiring a full pixel decoder. For CLI interactions, it adds a \BoundedTail\ mechanism that captures child-process output in a bounded, redacted manner to prevent credential leaks while preserving diagnostic evidence. Additionally, it standardizes JSON and XML escaping, defines a canonical grammar for collaboration document IDs, and establishes shared contracts for shader turbulence presets.

crates/op-util · high confidence

New release and security validation tooling for macOS, Android, and collaboration boundaries

The \tools/\ directory now includes a suite of new scripts that enforce structural and security contracts for release pipelines and collaboration infrastructure. \bundle-macos.sh\ assembles the desktop binary into a code-signed \OpenPencil.app\ bundle, ensuring the signing identity matches the TypeScript app to inherit macOS TCC folder-access grants. Structural validation for mobile releases is provided by \check-android-release-workflow.sh\ and \check-ios-app-store-workflow.sh\, which verify that the GitHub Actions workflows for Android and iOS adhere to strict security policies (e.g., secret scoping, environment requirements, and artifact provenance). Collaboration security is hardened by \check-collab-security-boundaries.sh\ and its associated test cases, which enforce deployment boundaries, credential ownership assertions, and relay URL canonicalization via \check-collab-bootstrap-urls.py\. Additionally, \check-file-line-cap.sh\ enforces the 800-line-per-file convention to maintain codebase discipline. Also in this area: 1 commit adding/updating tests in tools; 1 commit (1 fix) fixing tools.

tools · medium confidence · unverified

New shared process I/O primitives for spawning and managing child processes

The \op-process-io\ crate introduces a new library of shared primitives for managing external processes. It provides \LineStreamChild\ for asynchronous spawning with piped stdin/stdout/stderr, allowing users to feed input, read output line-by-line, and manage process lifecycles. The library also includes \ProcessTree\ utilities to safely terminate entire process groups on Unix (using process groups) or descendant trees on Windows, ensuring that child processes and their descendants are properly cleaned up. Additionally, it offers blocking helpers like \wait\_for\_child\_or\ for polling readiness signals while monitoring process exit status, and \spawn\_null\ for launching detached daemon-like processes with null stdio.

crates/op-process-io · high confidence

New template generation system and initial scene/deck templates

The \templates/step0/\_generators\ directory now contains the core infrastructure for generating scene and deck templates, including shared libraries (\cardlib.py\, \deckkit.py\, \oplib.py\) and build scripts (\bake\_hints.py\, \previews.sh\). This infrastructure supports the new initial template set, which includes screenshot tutorials, knowledge carousels, before-after comparison cards, and several deck styles (e.g., sounding-navy, tidemark-slate) with specific design constraints and typography rules.

_templates/step0/\generators · high confidence

New web shell host page and missing-bundle error page

The \op-host-services\ daemon now serves a dedicated \index.html\ for the OpenPencil web shell, which initializes the WASM canvas, handles device-pixel-ratio scaling, and logs smoke-test markers to the console for headless verification. Additionally, a \missing\_bundle.html\ page is served when the required WASM bundle files are not found, providing clear instructions on how to rebuild the bundle or configure the \OPENPENCIL\_WEB\_BUNDLE\_DIR\ environment variable.

_crates/op-host-services/src/web\static · high confidence

OpenHarmony NAPI engine bindings for mobile editing

This change introduces the \op-engine-napi\ crate, providing the Node-API (NAPI) bindings that allow the OpenHarmony (OHOS) ArkTS shell to load \libopenpencil.so\ and communicate with the OpenPencil engine. It exposes the full editor API surface—including lifecycle management, canvas gestures, text editing, IME, and document save/export workflows—mapped to OHOS-specific input mechanisms like mouse wheel zoom, hardware key modifiers, and system pasteboard integration. The bindings reuse the engine-thread marshalling and handle registry from the Android JNI crate to ensure consistent teardown ordering, while target-gating the OHOS-specific code so the crate compiles as an inert stub on non-HarmonyOS platforms.

crates/op-engine-napi · high confidence

Ported Rust design-lint crate for automated design diagnostics and fixes

The \op-design-lint\ crate introduces a Rust-based implementation of the design diagnostics layer, ported from the TypeScript \pen-ai-skills\ package. It provides pure, editor-agnostic detectors that analyze the \PenDocument\ tree for issues such as missing progress rings, WCAG color contrast violations, empty panels, and structural inconsistencies. The crate includes a \fixes\ module that automatically applies safe corrections (like clearing effects or adjusting padding) and a \design\_form\ classifier that identifies root surfaces as mobile, page, deck, or card based on artboard dimensions. This enables the editor to run pre-validation repairs and report structural quality before rendering.

crates/op-design-lint/src · high confidence

Preview session now supports multi-screen App Mode with automatic navigation wiring

When you preview a document containing multiple screen-marked frames, the preview session now enters 'App Mode' instead of showing a single-page workbench view. The system automatically wires navigation between these screens at preview entry time if no manual markers are present, allowing you to switch between screens via a pill row or edge-swipe gestures. This behavior is isolated to the preview environment and does not modify your saved document.

crates/op-preview-core · high confidence

Production deployment scaffolding for overseas-to-CN collaboration relay and locator ingress

This change introduces the \deploy/collab-relay-edge\ and \deploy/collab-relay-locator-edge\ directories, providing the complete production deployment configuration for connecting overseas users to China-anchored collaboration relays and locator services. It includes Nginx stream proxy configurations that perform nested TLS wrapping (outer mTLS over inner client TLS) to ensure the Global edge never terminates or inspects user traffic. The deployment uses Docker Compose with strict security constraints (read-only filesystems, non-root users, dropped capabilities) and pinned image digests. It also provides shell scripts for installing host-level nftables rate-limiting rules for new connections, validation scripts to enforce configuration integrity, and helper scripts for rotating Certificate Revocation Lists (CRLs) for the outer mTLS backhaul.

deploy · high confidence

Project initialization and repository scaffolding

The repository has been initialized with the foundational structure for the OpenPencil project. This includes the addition of standard configuration files such as \.dockerignore\, \.editorconfig\, \.gitattributes\, and \.gitmodules\ to manage submodules and formatting. The project is now licensed under the MIT License, and the \AGENTS.md\ file provides guidance for AI coding assistants. Additionally, localized README files (German, Spanish, French, Hindi, Indonesian) have been added to support international users, and a Dockerfile for the Rust web host has been introduced to containerize the application.

(repo-wide) · high confidence

Structured three-way merge for OpenPencil documents

The new \op-opmerge\ crate introduces a structural, node-level three-way merge engine for \.op\ documents, replacing fragile textual JSON merging. It automatically merges independent property changes (such as moving or recoloring distinct nodes) while surfacing genuine divergences—like conflicting edits to the same node, structural reorders, or reparenting—as \NodeConflict\ objects for the editor to resolve. This ensures that collaborative edits are preserved without silent data loss or broken JSON structures.

crates/op-opmerge · high confidence

Vendor Anthropic Agent SDK for Rust

The \vendor/anthropic-agent-sdk\ directory has been added as the source-of-truth for the Rust SDK, bringing in version 0.2.75. This update introduces OAuth 2.0 authentication with PKCE support for Claude Max/Pro subscribers, allowing browser-based login without API keys. It also adds experimental file checkpointing and rewind capabilities, new hook input types for session management, and a comprehensive TUI demo with interactive features. The SDK maintains full parity with the TypeScript version, including support for MCP servers, permission callbacks, and secure subprocess communication.

vendor/anthropic-agent-sdk · high confidence

iOS packaging scaffolding and native sign-in assets

The iOS packaging directory now includes the foundational project structure and assets for the mobile shell, including the Info.plist with URL schemes for WeChat, Alipay, and Douyin, entitlements for Apple Sign-In and universal links, and asset catalogs for provider icons. It also introduces the native sign-in implementation files (such as AlipayNativeSignIn and AccountCenterViewController) and localized strings for the login, registration, and account management flows, enabling platform-native authentication and account management on iOS. Also in this area: 1 commit (1 fix) fixing crates/op-hosted-models, packaging.

packaging/ios, packaging/ios/Sources, packaging/ios/Tests · low confidence · unverified

Removals

Removed initial editor UI components

Deleted the initial set of React components that formed the application's user interface, including the Header, EditorLayout, Toolbar, and LayerPanel, as well as the PropertyPanel and its sub-sections (Size, Fill, Stroke, Appearance, CornerRadius, Text) and shared UI primitives (ColorPicker, NumberInput, SliderInput, DropdownSelect, IconButton).

src/components · high confidence

Architecture

Canvas engine refactored into modular React hooks

The monolithic Fabric.js canvas implementation in src/canvas has been decomposed into a set of specialized, reusable React hooks to improve maintainability and separation of concerns. The previous single-file FabricCanvas component and associated constants have been replaced by dedicated hooks: use-fabric-canvas for initialization and resizing, use-canvas-events for pointer interactions and tool handling, use-canvas-selection for managing object selection state, use-canvas-viewport for zoom and pan logic, and use-canvas-sync for keeping the Fabric canvas in sync with the document store. Supporting utilities like canvas-object-factory and canvas-object-sync have also been modularized. This change restructures how the canvas engine is wired together without altering the underlying rendering capabilities.

src/canvas · high confidence

Extract collaboration runtime into dedicated op-collab-host crate

The collaboration runtime logic has been extracted into the new \op-collab-host\ crate, separating it from the desktop application code. This new crate provides a host-agnostic runtime that manages owner and guest actors, admission queues, relay control planes, and ticket verification. It introduces a \BlockingExecutor\ trait to bridge asynchronous network operations (like JWKS fetching) to synchronous host loops, and a \CollabHost\ trait to abstract editor state mutations and ID allocation policies, allowing the same runtime to drive both GUI hosts and headless test/daemon environments.

crates/op-collab-host/src · high confidence

Extracted op-ai crate for transport-free AI chat and agent settings

The \op-ai\ crate has been extracted from \openpencil-shell-core\ to centralize transport-free data shapes and logic for the editor's AI chat and agent integration. This new module provides the core types and behaviors for the multi-section settings modal (including agent providers like Claude Code, Copilot, and DeepSeek Harness, and MCP CLI toggles), a sliding-window chat history trimmer that preserves context continuity, and a model catalog structure. It also includes transport-agnostic SSE payload parsers for Anthropic and OpenAI-compatible providers, stateful tool-call accumulators for agent loops, and shared helpers for generating and cleaning design.md system prompts. By isolating these components, the crate ensures that the native desktop and web shells share identical AI logic without pulling in platform-specific dependencies like Tokio or reqwest.

crates/op-ai · high confidence

Refactor chat intent module into focused sub-modules

The \chat\_intent\ module has been split into separate files (\context.rs\ and \turns.rs\) to improve maintainability and keep the main module under the 800-line limit. This refactoring preserves all existing functionality, including append intent detection, design modification planning, and turn routing logic, while organizing the code into logical components for better readability and future development.

_crates/op-host-services/src/chat\intent · high confidence

Behavioural changes

1 commit (0 fixes) modifying crates/op-brand

A change to existing behaviour in crates/op-brand — 1 commit, 14 files: “feat(variables): extract brand kits into design variables”.

crates/op-brand · medium confidence · unverified

162 commits (42 fixes) modifying crates/op-host-native/src

A change to existing behaviour in crates/op-host-native/src — 162 commits (42 fixs), 6 files: “fix(editor): accept ime punctuation that commits without a composition”; “feat(editor): a11y + single-instance + layer-panel Rust↔TS parity”; “fix(ai): reveal design json copy on hover”; and 159 more (refs \#213).

crates/op-host-native/src · medium confidence · unverified

17 commits (5 fixes) modifying crates/op-host-native/examples

A change to existing behaviour in crates/op-host-native/examples — 17 commits (5 fixs), 10 files: “feat(desktop): adopt the casement winit fork”; “feat(editor): paint the App example art in the UI locale”; “feat(editor): Studio entry surface — task home, generation workspace, Agent rail”; and 14 more.

crates/op-host-native/examples · medium confidence · unverified

17 commits (6 fixes) modifying crates/op-engine-ffi/include

A change to existing behaviour in crates/op-engine-ffi/include — 17 commits (6 fixs), 1 file: “fix(editor): stabilize mobile collaboration”; “feat(editor): complete mobile player interactions and sign-in”; “feat(editor): enable secure mobile collaboration”; and 14 more.

crates/op-engine-ffi/include · medium confidence · unverified

2 commits (0 fixes) modifying crates/op-host-services/src/export\_pptx

A change to existing behaviour in crates/op-host-services/src/export\_pptx — 2 commits, 9 files: “feat(editor): export a deck as an editable powerpoint file”; “chore: upgrade zip and preserve deflate exports”.

_crates/op-host-services/src/export\pptx · medium confidence · unverified

2 commits (1 fix) modifying crates/op-builtin-model-discovery

A change to existing behaviour in crates/op-builtin-model-discovery — 2 commits (1 fix), 1 file: “fix(agent): upgrade Copilot SDK and CLI lifecycles”; “feat(ai): support multi-model provider discovery”.

crates/op-builtin-model-discovery · medium confidence · unverified

2 commits (1 fix) modifying crates/op-hosted-models

A change to existing behaviour in crates/op-hosted-models — 2 commits (1 fix), 8 files: “fix(editor): add scoped ios account deletion”; “feat(ai): share hosted runtime across native and mobile editors”.

crates/op-hosted-models · medium confidence · unverified

28 commits (8 fixes) modifying crates/op-host-desktop/src/app\_handler

A change to existing behaviour in crates/op-host-desktop/src/app\_handler — 28 commits (8 fixs), 5 files: “feat(editor): add delayed top-bar tooltips”; “feat(editor): add user and logo scene templates”; “feat(collab): add authenticated p2p collaboration”; and 25 more.

_crates/op-host-desktop/src/app\handler · medium confidence · unverified

3 commits (0 fixes) modifying packaging/android/gradle

A change to existing behaviour in packaging/android/gradle — 3 commits, 3 files: “feat(mobile): add native WeChat sign-in on ios, android, and harmony”; “feat(mobile): add native douyin and alipay sign-in on ios, android, and harmony”; “refactor(mobile): rename packaging players to packaging/ios and packaging/android”.

packaging/android/gradle · medium confidence · unverified

3 commits (1 fix) modifying packaging/ios/scripts

A change to existing behaviour in packaging/ios/scripts — 3 commits (1 fix), 1 file: “fix(ios): refresh republished wechat sdk archive pin”; “feat(mobile): add native WeChat sign-in on ios, android, and harmony”; “feat(mobile): add native douyin and alipay sign-in on ios, android, and harmony”.

packaging/ios/scripts · medium confidence · unverified

42 commits (17 fixes) modifying crates/op-host-native/src/backend/skia

A change to existing behaviour in crates/op-host-native/src/backend/skia — 42 commits (17 fixs), 15 files: “fix(editor): improve import and generation reliability”; “fix(canvas): don't arm an erase frame when a design run finishes empty”; “fix(ci): skip windows skia text height parity”; and 39 more (refs \#194, \#27).

crates/op-host-native/src/backend/skia · medium confidence · unverified

423 commits (169 fixes) modifying crates/op-host-native/src/widget\_host

A change to existing behaviour in crates/op-host-native/src/widget\_host — 423 commits (169 fixs), 241 files: “fix(editor): accept ime punctuation that commits without a composition”; “feat(editor): support generated widgets and ai canvas polish”; “feat(editor): a11y + single-instance + layer-panel Rust↔TS parity”; and 420 more (refs \#213, \#27, \#172).

_crates/op-host-native/src/widget\host · medium confidence · unverified

436 commits (141 fixes) modifying crates/op-editor-core/src

A change to existing behaviour in crates/op-editor-core/src — 436 commits (141 fixs), 270 files.

crates/op-host-desktop/assets · medium confidence · unverified

5 commits (0 fixes) modifying packaging/android

A change to existing behaviour in packaging/android — 5 commits, 4 files: “feat(editor): complete mobile editing workflows”; “feat(ai): run the full design pipeline on mobile, script mode included”; “chore(editor): prepare hosted-enabled v0.8.5 mobile release”; and 2 more.

packaging/android · medium confidence · unverified

5 commits (1 fix) modifying crates/op-host-native/src/widget\_host/input\_tests

A change to existing behaviour in crates/op-host-native/src/widget\_host/input\_tests — 5 commits (1 fix), 7 files: “feat(editor): Studio entry surface — task home, generation workspace, Agent rail”; “fix(ai): send the visible IME composition in chat prompts”; “feat(editor): complete mobile editing workflows”; and 2 more.

_crates/op-host-native/src/widget\_host/input\tests · medium confidence · unverified

50 commits (17 fixes) modifying crates/op-host-native/src/backend

A change to existing behaviour in crates/op-host-native/src/backend — 50 commits (17 fixs), 4 files: “fix(editor): improve import and generation reliability”; “feat(panels,canvas): editable gradients/effects + SVG/image import + locale-aware dialogs”; “fix(canvas): don't arm an erase frame when a design run finishes empty”; and 47 more (refs \#194).

crates/op-host-native/src/backend · medium confidence · unverified

6 commits (1 fix) modifying crates/op-host-desktop/src/figma\_import\_session

A change to existing behaviour in crates/op-host-desktop/src/figma\_import\_session — 6 commits (1 fix), 8 files: “feat(collab): add authenticated p2p collaboration”; “feat(editor): improve document workflows and rendering”; “refactor: typed error enums across the whole workspace”; and 3 more.

_crates/op-host-desktop/src/figma\_import\session · medium confidence · unverified

8 commits (4 fixes) modifying crates/op-host-native/src/context

A change to existing behaviour in crates/op-host-native/src/context — 8 commits (4 fixs), 3 files: “feat(desktop): adopt the casement winit fork”; “refactor(rust): rename native + desktop hosts to op-host-\* crates”; “fix(renderer): defer desktop gl startup”; and 5 more.

crates/op-host-native/src/context · medium confidence · unverified

Build system now detects changes to built-in agent skill files

A new build script has been added to ensure that modifications to the built-in agent's skill definitions (located in the \skills/\ directory) trigger a rebuild of the crate. Previously, adding or editing a skill markdown file would not cause the binary to rebuild, potentially leading to the application serving a stale corpus of skills until a manual rebuild was performed.

crates/op-ai-skills · high confidence

Enforce pre-commit checks for version consistency and Rust code quality

A new pre-commit hook has been added to automatically verify version consistency and enforce Rust code standards before changes are committed. The hook runs a version synchronization check and ensures that Rust code is properly formatted and free of clippy warnings, preventing non-compliant code from entering the repository.

.githooks · high confidence

Git version control engine migrated from subprocess to in-process libgit2

The \op-git\ crate now implements all Git operations (branching, merging, history, remotes, status, and credential management) using the in-process \libgit2\ library instead of spawning the system \git\ executable. This change eliminates the dependency on a system \git\ binary, resolving sandboxing issues on macOS and ensuring version control works on machines without \git\ installed. The public API surface and error handling remain compatible with the previous implementation, but the underlying execution model is now fully self-contained within the application binary.

crates/op-git · high confidence

Introduce Ed25519-based collaboration authentication with minimized relay tokens

The collaboration authentication system now uses strict Ed25519 JWS credentials instead of the legacy polymorphic EdDSA identifier. This change introduces a new, minimized relay bearer token that contains only the session expiry and channel-binding data, deliberately excluding account subjects, device IDs, and profile information to prevent third-party relays from reconstructing the social graph. The system also implements a bounded, rotation-aware JWKS cache that supports both legacy JWKS endpoints and new offline-signed union policies, ensuring that key verification remains secure and resource-bounded during trust-root rotations.

crates/op-auth-bridge/src · high confidence

Introduce signed, hardened op-auth ABI v3 prebuilt matrix

The \crates/op-auth-bridge/prebuilt\ directory now contains a complete, signed release matrix for op-auth version 0.8.5 across ten targets (macOS, iOS, Android, Linux, and Windows on x86\_64 and ARM64). These prebuilt libraries are hardened (stripped, fat LTO) and bound to ABI v3, with provenance signed by a new Ed25519 trust root (\PROVENANCE\_PUBKEY\). This enables the application to accept and verify these signed artifacts, ensuring that the private authentication components are immutable and auditable without requiring a local rebuild for every source change.

crates/op-auth-bridge/prebuilt · high confidence

Live MCP endpoint now enforces strict browser-screening admission control

The local live MCP endpoint now rejects requests from foreign hosts or origins to prevent DNS rebinding attacks, while removing the previous per-instance token requirement for local clients. This change introduces an admission gate that validates the \Host\ and \Origin\ headers, allowing only loopback addresses and the instance's own origin, with specific exceptions for browser extensions and stateless probes. Existing local tools like the CLI and VS Code proxy continue to work without the token, as trust is now established through boundary checks rather than shared secrets.

_crates/op-host-services/src/mcp\live · high confidence

OpenPencil VS Code extension restructured into workspace package with unified editor and daemon lifecycle

The OpenPencil VS Code extension has been moved into the \packages/op-vscode\ workspace directory and restructured to manage a unified custom editor provider that adapts to workspace trust. In untrusted workspaces, the extension displays a restricted placeholder; upon granting trust, it asynchronously assembles the full stack—including the platform daemon, MCP proxy, and session registry—and reopens the editor tabs. The extension now ships with a bundled platform daemon and web assets, resolving the binary from the vsix when available, and supports opening \.fig\ files by converting them via the daemon endpoint. A smoke test has also been added to verify the toolchain.

packages/op-vscode/src · high confidence

Removal of legacy TanStack Router setup and global styles

The application has removed the previous TanStack Router configuration files (\src/router.tsx\ and \src/routeTree.gen.ts\) along with the global stylesheet (\src/styles.css\). This eliminates the manually defined route tree and Tailwind-based base styles, indicating a migration to a new routing or styling architecture that no longer relies on these specific legacy setup files.

src · high confidence

Removal of legacy canvas and document stores

The legacy \canvas-store.ts\ and \document-store.ts\ files have been deleted from the \src/stores\ directory. This removes the previous Zustand-based state management implementations for canvas interactions (tools, viewport, selection) and document tree operations (node insertion, removal, and movement), indicating a shift to a new store architecture or state management approach.

src/stores · high confidence

Removal of legacy route definitions

The root layout, editor, and landing page route files have been deleted from the application. This removes the previous implementation of the main shell component, the editor interface, and the home page, indicating a structural change to how the application's navigation and core views are defined.

src/routes · high confidence

Removal of legacy type definitions for canvas, nodes, styles, and variables

The type definitions located in src/types (canvas.ts, pen.ts, styles.ts, and variables.ts) have been deleted. This removes the previous schema for document nodes (such as FrameNode, TextNode, and RefNode), styling properties (including fills, strokes, and effects), and canvas interaction states. Users relying on these specific type exports for external tooling or custom integrations will need to update their code to align with the new type structure introduced in the current version.

src/types · high confidence

Removal of local keyboard shortcut handling hook

The \useKeyboardShortcuts\ hook in \src/hooks\ has been removed, eliminating the local implementation that mapped keys (such as V, F, R, O, L, T, P, H for tools, Escape, Delete, Cmd+A, brackets, and arrows) to canvas actions like tool switching, selection, deletion, and nudge. Users relying on these specific keyboard bindings will no longer have them processed by this hook; the functionality has likely been migrated or replaced elsewhere in the application.

src/hooks · high confidence

Revived A/B testing corpus with v3 prompts for new tools and composite layouts

The A/B testing corpus has been restored to the \scripts/ab-v9\ location and upgraded to version 3. This update preserves the original 40 prompts from v1 to ensure result comparability, while adding 7 new prompts that cover recently introduced element tools (such as \setting\_row\, \filter\_group\, and \activity\_log\) and 5 new 'composite' difficulty prompts designed to evaluate the model's ability to handle multi-component layouts where no single tool applies.

scripts/ab-v9 · high confidence

Safer document saves and collapsed layer panels on open

The document I/O layer now uses atomic file writes (creating sibling temporary files and replacing the destination) to prevent data loss during crashes or overlapping saves, with a dedicated Windows serialization path to avoid file-replacement races. When opening a document, top-level frames are now collapsed in the Layer Panel by default, making large decks easier to navigate. The system also introduces a typed error model for document I/O and a compatibility report that tracks legacy schema repairs, sidecar usage, and metadata inference.

_crates/op-host-services/src/doc\io · high confidence

Style guide isolation and structural validation

The style guide system now enforces strict isolation and structural integrity. Audit tests verify that the tag vocabulary is well-formed, that exact-name lookups are reproducible for subagents, and that every guide contains required Color System and Typography sections. The registry is confirmed to be purely local and embedded, returning at least 50 guides without network I/O. Additionally, the card expansion logic now correctly distinguishes between corpus and user-imported guides, ensuring that imported guides are marked as such and that stale pins expand to nothing.

_crates/op-ai-skills/src/style\guide · high confidence

Fixes

1 commit (1 fix) fixing crates/op-pen-loader/fixtures

A fix in crates/op-pen-loader/fixtures — 1 commit (1 fix), 1 file: “fix(renderer): expand normal-mode presentation without changing preview”.

crates/op-pen-loader/fixtures · medium confidence · unverified

1 commit (1 fix) fixing crates/op-smoke/examples

A fix in crates/op-smoke/examples — 1 commit (1 fix), 1 file: “fix(ai): preserve mobile detail actions and readable metadata”.

crates/op-smoke/examples · medium confidence · unverified

14 commits (8 fixes) fixing crates/op-host-desktop/src/image\_search\_session\_tests

A fix in crates/op-host-desktop/src/image\_search\_session\_tests — 14 commits (8 fixs), 11 files: “feat(collab): add authenticated p2p collaboration”; “fix(ai): preserve image fallbacks through bounded selection”; “fix(desktop): preserve full image intent across search sessions”; and 11 more.

_crates/op-host-desktop/src/image\_search\_session\tests · medium confidence · unverified

31 commits (16 fixes) fixing crates/op-chat-agent

A fix in crates/op-chat-agent — 31 commits (16 fixs), 52 files: “fix(ai): hold the status-bar contract past root creation”; “feat(mcp): expose complete design pipeline context”; “feat(ai): script-first build protocol, right-sized mobile tools, and image search on the ffi hosts”; and 28 more.

crates/op-chat-agent · medium confidence · unverified

38 commits (28 fixes) fixing crates/op-image-enrich

A fix in crates/op-image-enrich — 38 commits (28 fixs), 51 files: “fix(ai): keep domain words in the image retry and fence logo hits”; “feat(ai): script-first build protocol, right-sized mobile tools, and image search on the ffi hosts”; “fix(ai): preserve image fallbacks through bounded selection”; and 35 more.

crates/op-image-enrich · medium confidence · unverified

5 commits (3 fixes) fixing crates/op-ai-skills/skills/phases/maintenance

A fix in crates/op-ai-skills/skills/phases/maintenance — 5 commits (3 fixs), 4 files: “feat(ai): add op-ai-skills crate — phase-driven prompt-skill engine”; “fix(ai): support script local edit apply”; “refactor(agent): make design repair explicit and bounded”; and 2 more.

crates/op-ai-skills/skills/phases/maintenance · medium confidence · unverified

5 commits (3 fixes) fixing templates/step0/\_generators/qa

A fix in templates/step0/\_generators/qa — 5 commits (3 fixs), 5 files: “fix(editor): let the template QA scripts run from any checkout and profile”; “chore(editor): keep the template QA gates beside the generators”; “fix(ai): compare the CJK tracking cap as a ratio, not a rounded number”; and 2 more.

_templates/step0/\generators/qa · medium confidence · unverified

55 commits (28 fixes) fixing crates/op-engine-ffi/src

A fix in crates/op-engine-ffi/src — 55 commits (28 fixs), 86 files: “fix(sdk): open the phone and tablet engine on Studio Home at a cold start”; “feat(ai): script-first build protocol, right-sized mobile tools, and image search on the ffi hosts”; “fix(editor): stabilize mobile collaboration”; and 52 more.

crates/op-engine-ffi/src · medium confidence · unverified

6 commits (4 fixes) fixing crates/op-host-desktop/src/image\_enrich\_cli

A fix in crates/op-host-desktop/src/image\_enrich\_cli — 6 commits (4 fixs), 1 file: “fix(ai): preserve image fallbacks through bounded selection”; “fix(cli): write the partially enriched document instead of discarding it”; “refactor(desktop): retry exhausted stock-image searches from a dedicated arm”; and 3 more.

_crates/op-host-desktop/src/image\_enrich\cli · medium confidence · unverified

6 commits (5 fixes) fixing crates/op-render-export

A fix in crates/op-render-export — 6 commits (5 fixs), 7 files: “fix(renderer): expand normal-mode presentation without changing preview”; “fix(renderer): export ordinary App screens as separate PDF pages”; “feat(mobile): document export, untitled start, and new-file action”; and 3 more.

crates/op-render-export · medium confidence · unverified

601 commits (388 fixes) fixing crates/op-orchestrator/src

A fix in crates/op-orchestrator/src — 601 commits (388 fixs), 725 files: “feat(orchestrator): plan\_normalize — dashboard section-size branch”; “fix(agent): stabilize compact status geometry”; “feat(editor): support generated widgets and ai canvas polish”; and 596 more (refs \#27, \#212).

crates/op-orchestrator/src · medium confidence · unverified

Build-time validation of collaboration hub URLs

The collaboration host crate now validates the \OPENPENCIL\_BUILD\_COLLAB\_BOOTSTRAP\_URL\_CN\ and \OPENPENCIL\_BUILD\_COLLAB\_BOOTSTRAP\_URL\_GLOBAL\ environment variables at build time. If a release pipeline injects a malformed hub URL—such as one with surrounding whitespace, a non-HTTPS scheme, or an incorrect path—the build will fail immediately. This prevents shipped binaries from silently failing to connect to the collaboration relay due to configuration errors.

crates/op-collab-host/src/runtime · high confidence

Test coverage

1 commit adding/updating tests in crates/op-host-desktop/src/collab\_runtime; 18 commits adding/updating tests in crates/op-host-native/tests; 2 commits adding/updating tests in crates/op-orchestrator/tests/fixtures/carousel-1018; 3 commits adding/updating tests in crates/op-host-services/src/pre\_validator; 4 commits adding/updating tests in packaging/android/app/src/test; 5 commits adding/updating tests in crates/op-host-native/src/backend/skia/tests; 6 commits adding/updating tests in packaging/android/Tests; 9 commits adding/updating tests in crates/op-orchestrator/tests/fixtures/subtask\_completeness; Added TypeScript bridge protocol codec and tests for VS Code extension communication; Added end-to-end smoke tests for the managed web server daemon; Added golden regression tests for op-design-lint Rust implementation; Added integration and unit tests for the collaboration transport layer; Added integration tests for the daemon client and MCP proxy; Added regression tests for fixed-size flex layout behavior; Added test coverage for authentication bridge components; Added test fixtures for HTML import and snapshot fidelity; Added tests for Rust planner prompt parity with TypeScript golden files; Added tests for chat agent identity, streaming stop behavior, and instance history states; Added tests for chat, codegen, and design session logic; Added unit tests for AI chat model picker, layer panel gutter, and widget rendering; Android packaging and player contract tests; New FFI integration tests for engine ABI, editor, and mobile safe-area contracts.

Dependencies

Rust workspace bootstrap and dependency lockfile generation

The project has been bootstrapped as a Rust workspace, introducing a \Cargo.lock\ file and a root \Cargo.toml\ that defines the workspace structure, default members, and release profile optimizations (thin LTO, codegen-units=1, symbol stripping). This change establishes the foundational dependency graph for the Rust-based editor, hosts, and CLI tools, replacing the previous TypeScript/Electron build system.

(dependencies) · high confidence

Vendor submodules initialized for agent, casement, and jian

The repository now tracks three new vendored submodules: \vendor/agent\ (commit 1bff904), \vendor/casement\ (commit ffdd672), and \vendor/jian\ (commit 338c0ba). These additions establish the baseline versions for the agent runtime, the winit-based windowing layer (casement), and the core UI/rendering framework (jian) used by the editor and renderer.

vendor · high confidence

Vendored CanvasKit artifacts for the web host

The web host now includes vendored CanvasKit assets (canvaskit.js and canvaskit.wasm, version 0.40.0) to enable rendering without relying on external node\_modules or embedded Skia runtimes. These files are served at the /canvaskit/ prefix and initialized via the op\_ck\_bridge.js FFI, ensuring the Rust web shell can render independently of the TypeScript application environment.

crates/op-host-web · 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 57 → 57 (+0.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 59 → 60 (+0.9)
  • Architecture 95 → 95 (-0.5)
  • Maturity 68 → 68 (-0.1)
  • Readiness 60 → 62 (+1.7)
  • Security 71 → 74 (+2.6)
  • Domain Modelling 100 → 100 (+0.0)
  • Event Sourcing 100 → 100 (+0.0)
  • Accessibility 48 → 46 (-1.5)
  • Performance 85 → 100 (+14.9)

Resolved (410)

  • Change coupling: main.rs ↔ chat_runtime.rs (crates/op-host-desktop/src/main.rs)
  • Change coupling: plan_normalize.rs ↔ variables.rs (crates/op-orchestrator/src/plan_normalize.rs)
  • Change coupling: subagent.rs ↔ variables.rs (crates/op-orchestrator/src/subagent.rs)
  • Change-coupling hub: mcp_serve.rs → command.rs, command_apply.rs, lib.rs, parser.rs, write_tools.rs (crates/op-host-desktop/src/mcp_serve.rs)
  • Change-coupling hub: prompt.rs → plan_normalize.rs, run_tests_b4.rs, variables.rs (crates/op-orchestrator/src/prompt.rs)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Duplicated block (10 lines × 2) (crates/op-collab/src/guest.rs)
  • Duplicated block (10 lines × 2) (crates/op-editor-core/src/color_picker_snapshot.rs)
  • Duplicated block (10 lines × 2) (crates/op-editor-ui/src/widgets/toolbar.rs)
  • Duplicated block (10 lines × 2) (crates/op-engine-jni/src/bindings.rs)
  • Duplicated block (10 lines × 2) (crates/op-orchestrator/src/concurrent.rs)
  • Duplicated block (10 lines × 3) (crates/op-collab-relay-control-plane/src/http_client.rs)
  • Duplicated block (10 lines × 3) (crates/op-design-lint/src/node_util.rs)
  • Duplicated block (10 lines × 3) (crates/op-orchestrator/src/cleanup_bottom_nav_repairs.rs)
  • Duplicated block (10–12 lines × 2) (crates/op-editor-core/src/svg_import/path_data.rs)
  • Duplicated block (10–13 lines × 2) (templates/step0/_generators/tpl_toolkit_carousel.py)
  • Duplicated block (11 lines × 2) (crates/op-ai-skills/src/style_guide/design_md_import.rs)
  • Duplicated block (11 lines × 2) (crates/op-ai/src/agent_settings_state.rs)
  • Duplicated block (11 lines × 2) (crates/op-ai/src/agent_settings_state.rs)
  • Duplicated block (11 lines × 2) (crates/op-editor-ui/src/widgets/agent_settings_builtin_model_menu.rs)
  • …and 390 more

New (1794)

  • AccountDeletionCoordinator.retry (cognitive 31) (packaging/ios/Sources/AccountDeletionCoordinator.swift)
  • AccountDeletionCoordinator.retry (cyclomatic 16) (packaging/ios/Sources/AccountDeletionCoordinator.swift)
  • AccountDeletionStore.validateLocation (cognitive 16) (packaging/ios/Sources/AccountDeletionState.swift)
  • AnnotateImage::call (cognitive 24) (crates/op-mcp/src/image_annotation.rs)
  • AnnotateImage::call (cyclomatic 22) (crates/op-mcp/src/image_annotation.rs)
  • BindingOverlay::update_scroll (cognitive 18) (crates/op-preview-core/src/binding_overlay.rs)
  • Boundary-crossing change coupling: de_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/de_collab.rs)
  • Boundary-crossing change coupling: en_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/en_collab.rs)
  • Boundary-crossing change coupling: es_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/es_collab.rs)
  • Boundary-crossing change coupling: fr_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/fr_collab.rs)
  • Boundary-crossing change coupling: hi_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/hi_collab.rs)
  • Boundary-crossing change coupling: id_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/id_collab.rs)
  • Boundary-crossing change coupling: ja_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/ja_collab.rs)
  • Boundary-crossing change coupling: ko_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/ko_collab.rs)
  • Boundary-crossing change coupling: pt_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/pt_collab.rs)
  • Boundary-crossing change coupling: ru_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/ru_collab.rs)
  • Boundary-crossing change coupling: th_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/th_collab.rs)
  • Boundary-crossing change coupling: tr_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/tr_collab.rs)
  • Boundary-crossing change coupling: vi_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/vi_collab.rs)
  • Boundary-crossing change coupling: zh_cn_collab.rs ↔ export-i18n-catalogs.py (crates/op-i18n/src/i18n/zh_cn_collab.rs)
  • …and 1774 more

Changes since last survey

  • 12 commits — 5 feature/other, 7 fixes

By area

  • crates/op-host-services — 4 commits
  • crates/op-acp — 2 commits
  • (root) — 1 commit
  • crates/op-auth-bridge — 1 commit
  • crates/op-orchestrator — 1 commit
  • packaging/ios — 1 commit
  • scripts/install-op.sh — 1 commit
  • tools/flatten-release-artifacts.test.sh — 1 commit

Notable commits

  • fix: fix(agent): probe Windows executable extensions before the bare name
  • fix: fix(ai): restore --destructive to the saturated-accent tokens
  • fix: fix(editor): add scoped ios account deletion
  • fix: fix(editor): update audited TLS and archive dependencies
  • fix: fix(install): fall back to the newest release when no stable release exists
  • fix: fix(release): keep the vsix daemon binary out of the release assets
  • fix: fix(web): isolate managed editor config and repair native CI (#252)
  • change: chore(agent): adopt scoped account auth matrix
  • change: docs(editor): remove api reseller ads from readmes
  • change: feat(mcp): expose deterministic code export for stable editor
  • change: test(web): align host catalog and isolate startup settings
  • change: test(web): keep server fixtures within the file line limit

Architecture

  • Unchanged — 0 containers · 2 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

ZSeven-W/openpencil 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 14 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 2bbc658caba5139cdfeb768b65da7f6f0080a703 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — 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.65+preprod-e1a3b69fc8ee.