pbakaus/impeccable

Impeccable is a design quality and anti-pattern detection system that provides a CLI, browser extension, and IDE integrations for AI coding tools. It uses a native Rust engine to perform deterministic UI audits, visual fidelity checks, and live variant generation across web and native platforms. The system supports multiple AI harnesses by offering a shared design vocabulary and automated hooks for real-time critique and refinement.

The Impeccable design skill has been updated to version 4.4.0, consolidating design, critique, and live-iteration capabilities into a single command set. This release introduces a new \.gemini/settings.json\ configuration that automatically triggers the \impeccable\ hook before shell commands and after agent completions, enabling real-time design feedback and context synchronization. The skill now includes comprehensive reference documentation for native platform adaptation (iOS and Android), technical auditing, and motion design, ensuring consistent quality across web and native interfaces.

.gemini · high confidence

The Impeccable skill now ships a self-contained launcher script (and Windows batch equivalent) that resolves and executes the platform binary, supporting automatic download, SHA-256 verification, and fallback to cached or PATH-installed versions without requiring Node.js. A new command-metadata.json defines the available skill verbs (such as init, document, live, generate, adapt, animate, audit, and polish) with descriptions and argument hints. Browser-side JavaScript modules for live mode have been added to handle DOM helpers, project-ignore resolution, and durable session state, enabling interactive live variant generation and design system extraction directly in the browser.

.vibe/skills/impeccable/scripts · high confidence

The Impeccable skill has been updated to version 0.1.6, introducing a comprehensive set of new commands and capabilities for design and development workflows. The update adds a detailed command metadata file defining actions such as 'init' for project setup, 'document' for generating design specs, 'live' for interactive variant generation, and 'generate' for agent-driven design variations. It also includes specialized commands for responsive design ('adapt'), animation ('animate'), technical auditing ('audit'), and various design refinements like 'bolder', 'quieter', 'polish', and 'typeset'. Additionally, a font index failure list has been added to track fonts that are not loaded or lack lettering data.

.veto/skills/impeccable/scripts · high confidence

The Impeccable skill has been updated to version 0.1.6, introducing a comprehensive set of new commands and data structures to enhance design and typography workflows. The \command-metadata.json\ file now defines 24 distinct commands, including \document\ for generating visual design specs, \live\ for interactive variant generation, \adapt\ for responsive design, \animate\ for micro-interactions, and \audit\ for technical quality checks. Additionally, new data files provide a detailed font index (\font-index.json\) for typography analysis and a list of known font index failures (\font-index-failures.json\), enabling the skill to better handle font-related edge cases and provide more accurate design recommendations.

.agent/skills/impeccable/scripts · high confidence

The Impeccable skill scripts have been updated to version 0.1.6, introducing a new launcher mechanism that resolves and executes the platform binary via a handshake probe to avoid conflicts with older CLI versions. This update adds comprehensive browser-side scripts for the new 'live mode' feature, including DOM helpers for element selection, session state management for recovery, and project ignore resolution to align browser findings with CLI configurations. A new \command-metadata.json\ file defines the available commands such as \init\, \document\, \live\, \generate\, and \audit\, while a bundled \modern-screenshot\ library is included to support screenshot capture capabilities within the live environment.

.hermes/skills/impeccable/scripts · high confidence

The Impeccable skill now includes a new version (0.1.6) and a comprehensive set of scripts that enable interactive live design experimentation and robust cross-platform execution. A new shell launcher (\impeccable\) and Windows batch file (\impeccable.cmd\) handle binary discovery, version pinning, and secure download/verification of the engine, ensuring the tool works without Node.js. The skill also introduces a 'Live Variant Mode' via browser-side JavaScript (\live-browser.js\, \live-browser-dom.js\, \live-browser-session.js\) that allows users to select elements in the browser, pick design actions, and receive AI-generated HTML+CSS variants hot-swapped via HMR. Additionally, \command-metadata.json\ defines a rich set of new commands like \live\, \generate\, \adapt\, \animate\, and \audit\, expanding the skill's capabilities beyond simple generation to include responsive adaptation, animation enhancement, and technical auditing.

.qoder/skills/impeccable/scripts · high confidence

The Impeccable skill now ships as a self-contained package (v0.1.6) with a platform-agnostic shell launcher (impeccable/impeccable.cmd) that resolves and executes the native engine binary, including automatic download, SHA-256 verification, and fallback logic for Windows ARM. The skill includes a full set of command metadata (craft, init, document, extract, live, generate, adapt, animate, audit, bolder, clarify, colorize, critique, delight, distill, harden, onboard, layout, optimize, overdrive, polish, quieter, shape, typeset) and browser-side scripts for live variant mode: DOM helpers (live-browser-dom.js), project ignore resolution (live-browser-ignores.js), durable session state (live-browser-session.js), and the main live overlay UI (live-browser.js). A bundled modern-screenshot.umd.js is also included to support screenshot capture in live mode.

.agents/skills/impeccable/scripts, .claude/skills/impeccable/scripts, .cursor/skills/impeccable/scripts · high confidence

The skill directory now ships a self-contained v0.1.6 launcher (impeccable/impeccable.cmd) that resolves and executes a native platform binary, supporting automatic download with SHA-256 verification and fallback to cached or PATH-installed engines. A new command-metadata.json defines the full set of Impeccable commands (init, live, generate, adapt, animate, audit, etc.) with descriptions and argument hints. Live mode is supported by new browser-side scripts: live-browser.js (the main overlay UI and session management), live-browser-dom.js (DOM helpers for element picking and framework HMR detection), live-browser-ignores.js (resolution of project detector waivers against page URLs), and live-browser-session.js (durable session state in localStorage). A bundled modern-screenshot.umd.js is also included for screenshot capabilities.

skill/scripts · high confidence

The Impeccable skill now ships a self-contained launcher script (impeccable/impeccable.cmd) that resolves and executes the platform-specific engine binary, including automatic download and SHA-256 verification when the binary is missing. A new command-metadata.json defines the available commands (init, live, generate, adapt, animate, audit, etc.) with descriptions and argument hints. Browser-side scripts for Live mode are added: live-browser.js provides the floating UI and variant cycling; live-browser-dom.js supplies DOM helpers for element picking and framework HMR ownership detection; live-browser-ignores.js resolves project-level detector waivers in the browser; and live-browser-session.js manages durable session state (checkpoints, handled IDs, scroll position) via localStorage. A VERSION file pins the skill to 0.1.6.

plugin/skills/impeccable/scripts · high confidence

The Impeccable skill is updated to version 0.1.6, introducing a new platform-agnostic launcher script (impeccable/impeccable.cmd) that resolves and executes the native engine binary with SHA-256 verification and fallback caching. The skill now includes a comprehensive set of browser-side scripts for Live Variant Mode, including DOM helpers, project ignore resolution, and durable session state management, enabling real-time visual experimentation and element picking in the browser. Additionally, the skill's command vocabulary has been expanded to 20 distinct commands (such as live, generate, adapt, animate, audit, and polish), providing a broader range of AI-assisted design and quality workflows.

(repo-wide) · high confidence

The Impeccable skill has been updated to version 4.4.0, introducing a new interactive 'live mode' that allows users to visually experiment with design alternatives in real-time via hot-swapped HTML+CSS variants in the browser. This update adds a suite of new design commands including \live\, \generate\, \adapt\, \animate\, \audit\, \bolder\, \clarify\, \colorize\, \critique\, \delight\, \distill\, \harden\, \onboard\, \layout\, \optimize\, \overdrive\, \polish\, \quieter\, \shape\, and \typeset\, each targeting specific aspects of UI/UX refinement from responsive design to accessibility and performance. The skill now includes a shell launcher (\impeccable\) and Windows batch script (\impeccable.cmd\) that handle binary discovery, version pinning, and secure download verification, alongside browser-side JavaScript modules (\live-browser.js\, \live-browser-dom.js\, \live-browser-session.js\, \live-browser-ignores.js\) that power the live mode interface, session state, and project-specific ignore rules.

.grok/skills/impeccable/scripts · high confidence

The Impeccable skill has been updated to version 0.1.6, introducing a new command metadata definition that exposes a wide range of design-focused capabilities including live variant generation, responsive adaptation, animation enhancement, technical auditing, and UX critique. The update also includes a new font index data file for typography analysis and a failure log tracking specific font families that could not be loaded or analyzed.

.dsh/skills/impeccable/scripts · high confidence

Introduces the Impeccable design skill and CLI, providing a shared design vocabulary and deterministic anti-pattern detection for AI coding tools. The skill includes 23 commands for design critique, refinement, and live iteration, while the CLI and browser extension run 61 deterministic rules to detect UI issues. The release includes a new Neo Kinpaku design system with specific color tokens and typography scales, and supports multiple AI harnesses including Claude, Cursor, and GitHub Copilot.

(repo-wide) · high confidence

Adds a new Chrome extension that detects UI anti-patterns using a WebAssembly rule core running in an offscreen document. The service worker manages per-tab state, injects content scripts on demand, and routes messages between the popup, DevTools panel, and the offscreen document. The content script captures page snapshots, answers runtime questions (hit tests, pixels) from the live page, and draws overlays for findings. The extension also surfaces scan failures (e.g., local file restrictions) and updates the toolbar badge with the total count of anti-pattern findings.

extension/background · high confidence

Adds a new Chrome DevTools extension that integrates an 'Impeccable' panel and sidebar into the browser's developer tools. The panel provides a dedicated UI for viewing detected anti-patterns, with controls to re-scan the page, toggle visual overlays, copy findings, and adjust settings such as auto-scan behavior, line length strictness, and spotlight blur. The sidebar pane displays findings specific to the currently selected element in the Elements panel, allowing developers to inspect issues directly in context. The extension communicates with a background service worker via persistent ports with automatic reconnection logic to handle service worker termination in Manifest V3.

extension/devtools · high confidence

Adds a new automated 'PR Sheriff' system (scripts/github/sheriff.mjs) that monitors open pull requests and applies labels to reflect their current status. The script automatically manages state labels such as 'waiting on contributor', 'needs maintainer review', and 'ready to merge', as well as blocker labels like 'blocked: ci' or 'blocked: merge conflicts'. It also handles stale detection, applying 'stale' labels to inactive PRs and providing configurable warning and auto-close timelines. The automation respects maintainer overrides via a '/sheriff wait' command and exempts specific labels (e.g., 'security') from automatic closure.

scripts/github · high confidence

This change adds a new component review checkpoint for human evaluation, including the \ui/component-review\ UI shell (layout, entry point, icons, fonts) and the \crates/cli/examples\ offline diagnostic drivers (\capture\_asset\, \capture\_service\_request\, \capture\_service\_roundtrip\, \capture\_snapshot\, \capture\_snapshot\_viewport\, \entry\_capture\_service\) that support the review workflow. The UI provides a browser-based interface for reviewing component inventories, comparing previews against design specs, and submitting feedback or approvals, while the CLI examples offer standalone tools for capturing assets, snapshots, and service roundtrips to generate the evidence needed for the review process.

crates/cli/examples, ui · high confidence

The landing demo now includes a formalized design system (Lumina) defined in DESIGN.json and DESIGN.md, specifying a warm-cream palette, Fraunces/Inter typography, and flat, rounded component styles, alongside a PRODUCT.md that outlines the brand's anti-monoculture positioning. Additionally, a new classic/index.html provides a contrasting dark-mode variant with purple/pink gradients and glassmorphism effects, offering users a distinct visual alternative to the primary editorial-warm theme.

demos · high confidence

The live server's core logic has been rewritten in Rust, replacing the previous JavaScript implementation. This change introduces new modules for CSS reconciliation and baking (\accept\_css\, \bake\), post-condition verification of accepted source (\accept\_verify\), browser script assembly and injection (\browser\_assets\), and automated browser launching (\browser\_open\). It also includes a new configuration parser (\config\), an AI-driven copy-edit agent runner (\copy\_edit\_agent\), and a design system markdown parser (\design\_md\). The Rust engine now handles the generate lane's mechanical bake, variant acceptance, and live-edit application, providing a single binary that replaces the prior script-based tooling.

crates/live/src · high confidence

The Impeccable extension is now packaged as a native Cursor plugin (version 4.4.0), providing a single skill and four specialist agents (Asset Producer, Documenter, Finish Reviewer, Manual Edit Applier) along with a pre-edit hook. This native plugin runs without a Node runtime, downloads the engine on first use, and is prepared for submission to the Cursor marketplace, offering an alternative to the existing \npx impeccable install\ project-level setup.

cursor-plugin · high confidence

The live server now includes a generated browser detector bundle (\detect-antipatterns-browser.js\) and a static rule registry (\antipatterns.json\) that enable in-page analysis of UI anti-patterns. The detector, compiled from the Rust core to WebAssembly and bundled with DOM probes, allows the browser to identify specific design issues such as AI-generated tells (e.g., generic color palettes, overused fonts, decorative animations) and quality defects (e.g., broken images, hidden content). The rule registry provides a structured list of these checks, ensuring that consumers can access the full set of detection rules even without a Rust toolchain.

crates/live/assets · high confidence

The scripts directory now includes a comprehensive set of build and release automation tools. The main build script (build.js) orchestrates the transformation of design skills into provider-specific formats (Cursor, Claude Code, Gemini, etc.), generates site counts, and validates plugin versions. A new extension build script (build-extension.js) compiles the Rust-based detector into WebAssembly, packages the Chrome and Firefox browser extensions, and verifies file integrity. Additional scripts handle fetching and verifying the native engine binaries (fetch-engine.mjs, check-engine-release.mjs), publishing platform-specific npm packages (publish-platform-packages.mjs), generating font indexes (build-font-index.mjs), and creating extension assets like icons and promo tiles. This replaces previous ad-hoc build processes with a unified, verified pipeline.

scripts · high confidence

The build system now generates distributable plugin packages for Cursor, OpenAI (Codex), and VS Code alongside the existing Claude Code support. New scripts/lib modules handle provider-specific manifest generation, path rewriting (e.g., replacing project-relative paths with host-specific variables like ${CLAUDE\_SKILL\_DIR} or ${CLAUDE\_PLUGIN\_ROOT}), and asset staging. Additionally, a test harness safety net was added to detect and kill orphaned live-server processes left behind by crashed or killed test runs, ensuring cleaner test environments.

scripts/lib · high confidence

The build pipeline now uses a new transformer system in scripts/lib/transformers to generate IDE-specific agent definitions and hook manifests for a wide range of providers, including Claude Code, Codex, Cursor, GitHub Copilot, Grok Build, Gemini, Kiro, OpenCode, Pi, Qoder, Rovo Dev, Mistral Vibe, Veto, Trae, Antigravity, and Hermes. This change introduces provider-specific formatting for agent files (e.g., TOML for Codex, Markdown with YAML frontmatter for Claude/Cursor/Copilot) and generates correct hook installation scripts for each environment, ensuring that design checks and deep-pass rules are properly wired into the respective IDEs' hook systems.

scripts/lib/transformers · high confidence

The VS Code extension now includes a \.vscodeignore\ file to control which files are packaged, ensuring only essential assets like \package.json\, \README.md\, \LICENSE\, \icon.png\, and the \skills/\ directory are included. This change supports the new skill-only packaging model, which bundles the skill, references, and engine launchers without an extension runtime, activation events, or telemetry code, as described in the updated \README.md\.

vscode · medium confidence

The CLI has been replaced by a Node.js shim that locates and executes a native Rust engine binary. This binary is delivered via platform-specific optional npm dependencies (e.g., @impeccable/cli-darwin-arm64) or, if unavailable, is securely downloaded and cached to the user's home directory with SHA-256 verification. The shim also changes the --version output to report the npm package version rather than the engine version, and provides clearer error messages if the binary cannot be located or executed.

cli · high confidence

The design detection hooks (PostToolUse per-edit pass, Stop deep pass, and Cursor pre-edit gate) have been rewritten in Rust, replacing the previous Node.js scripts. This change introduces a native binary launcher for the hooks, updates the hook manifest formats to use the new launcher paths, and adds support for relocating the hook state cache to a custom directory via the IMPECCABLE\_CACHE\_ROOT environment variable.

crates/hook · high confidence

The workspace now uses a new Rust binary (\crates/xtask\) to replace previous scripts and the JS detector for building the in-page detector bundle. Running \cargo xtask bundle\ compiles the WebAssembly module, concatenates it with JavaScript glue code, and generates two tracked assets: \dist/detect-antipatterns-browser.js\ and \crates/live/assets/antipatterns.json\. It also produces extension-specific files (snapshot.js, overlay.js, core.js, core\_bg.wasm) into \extension/detector/\. The task supports a \--check\ flag to verify that these generated assets are up-to-date, serving as a staleness gate for CI.

crates/xtask · high confidence

The URL scanning engine in \impeccable detect\ has been rewritten in Rust (\crates/browser\), replacing the previous JavaScript-based puppeteer implementation. This new engine discovers installed Chromium-based browsers (Chrome, Edge, Brave, etc.) via environment variables and standard OS paths, then drives them using a custom, synchronous Chrome DevTools Protocol (CDP) client. Key behavioral changes include: 1) \*\CSP Passivity\\: Scans no longer bypass Content Security Policy (\Page.setBypassCSP\ is removed), meaning strict-CSP sites are scanned passively without executing blocked inline scripts, verified by new tests. 2) \\Snapshot-Based Analysis\\: Instead of injecting a WebAssembly detector bundle into the page, the engine now injects a plain-JS snapshot producer, captures the DOM as JSON, and runs the rule core natively in Rust over a \SnapshotDom\ structure. 3) \\Visual Contrast\\: The screenshot-based contrast check is now performed natively in Rust by decoding PNGs and diffing pixels, replacing the in-page canvas diff. 4) \\Shared Browser\\: Multiple URLs can now share a single browser instance for efficiency, with lazy launching and proper error handling. 5) \\Response Capture\\*: An opt-in, bounded CDP response evidence system captures network responses for deeper analysis. This change improves performance, reduces dependencies, and ensures scans are more passive and secure.

crates/core · high confidence

The CLI now captures visual evidence directly from frozen, immutable static HTML snapshots using a dedicated Rust engine and isolated Chromium instances, eliminating the previous reliance on Node.js scripts and JS-based detection. This change introduces a new capture pipeline that validates exact file contents, enforces strict dependency pinning, and uses software rasterization to ensure pixel-perfect, reproducible screenshots for both entry points and individual components.

crates/cli/src · high confidence

The extension now features a redesigned popup interface that displays the current anti-pattern count, provides buttons to scan the page and toggle overlays, and explicitly surfaces scan failures via a dedicated error message area. This change updates the user experience by making it clear when a scan cannot complete, rather than silently failing or leaving the UI in an ambiguous state.

extension/popup · high confidence

The browser-bundle has been restructured into a modular set of JavaScript files (00-header through 99-footer) that are concatenated into a single in-page bundle. This new architecture introduces a dedicated DOM probe (10-probe.js) to handle element registry and style queries, a snapshot producer (15-snapshot.js) for offscreen document analysis, and a new visual-contrast sampling system (35-visual.js) that supports image-backed text detection. The overlay UI (40-overlay.js) has been updated with a new 'Kinpaku' gold theme for highlighting findings, and the scan logic (50-scan.js, 60-offscreen.js) now bridges to a Rust-based WASM rule core, replacing previous script-based detection methods.

browser-bundle · high confidence

The comp-fidelity verification workflow—previously implemented in JavaScript scripts—is now executed natively within the Rust engine via the new \crates/comp-verbs\ crate. This change introduces four core orchestrators: \comp-spec\ (generating measured build specs from approved comps), \comp-diff\ (scoring structure, color, detail, and bands between comps and builds), \font-match\ (ranking candidate typefaces by fingerprint distance), and \build-phase\ (managing the multi-stage fidelity gate state machine). By moving these capabilities into the engine, the tool no longer relies on external Node.js processes for these checks, and the pure logic is kept free of the closed-source \core\ crate by injecting browser-dependent rendering (for fonts and organic CSS scans) at runtime.

crates/context · high confidence

The project has replaced the previous JavaScript-based scripts and detector with a Rust engine. This change introduces a new \impeccable-bundle\ crate that generates the browser artifacts, including the in-page bundle (\detect-antipatterns-browser.js\) and the extension pieces (snapshot, overlay, and core scripts). The Rust engine also provides a \common\ crate with utilities for path handling and process management, replacing Node.js dependencies. The extension's offscreen document now hosts the WebAssembly rule core, leveraging the new Rust-based detection logic.

crates/bundle, crates/common, extension/offscreen · high confidence

The accessibility detection engine has been rewritten in Rust, replacing the previous JavaScript-based detector and associated scripts with a single binary. This change introduces a new \Dom\ trait in \crates/foundation/src/browser/dom.rs\ that standardizes DOM measurements (such as computed styles, geometry, and text layout) across live browser probes, page snapshots, and unit test fakes, ensuring consistent rule evaluation regardless of the execution environment.

crates/foundation · high confidence

The skills management logic (install, update, check, link) has been ported from Node.js to a Rust engine, introducing three key behavioral changes for users. First, remote skill bundles are now verified against an Ed25519 signature using a compiled-in keyring before extraction, ensuring authenticity. Second, the engine automatically downloads and installs the corresponding \impeccable\ binary for each skill version, making the installed skills self-contained and removing the dependency on a global Node.js runtime for hook execution. Third, hook manifests are rewritten to invoke the local launcher binary instead of \node\, ensuring consistent behavior across providers like Cursor, Claude, and Codex.

crates/skills · high confidence

A new shared CSS file (kinpaku.css) introduces a consistent 'paper and ink' visual system across the extension's popup, DevTools panel, sidebar, and overlays. This update defines a specific color palette (gold, patina, vermilion, paper, ink), typography using system font stacks to match the site's design, and UI components like the brand mark, tags, and controls, ensuring the extension's interface aligns with the main site's aesthetic.

extension/shared · high confidence

The HTML detection engine has been rewritten in Rust to replace the previous JavaScript implementation, enabling a single binary to perform static analysis without a browser or Node.js runtime. This port includes a full CSS cascade parser (ported from css-tree 3.2.1) to resolve styles, background color computation, and DOM adapters that map static elements to the core accessibility checks. The change also adds example utilities for JSON output and unsupported selector detection, and fixes placeholder contrast detection logic to align with the new static engine.

crates/html · high confidence

The \impeccable detect\ command and its supporting logic (config parsing, file walking, regex-based text scanning, design system handling, and the \impeccable ignores\ command) have been ported from JavaScript to Rust. This replaces the previous Node.js-based implementation, providing a single binary that handles static HTML, non-HTML source files, and URL scanning without requiring a separate JS runtime for the detection engine.

crates/detect · high confidence

Added framework fixture suites for E2E testing; Added integration tests for CLI capture, agent targeting, and server security; Added skill-behavior test suite for LLM-driven skill protocol verification; Added test coverage for the skills transformer factory and provider-specific output logic; Added test fixtures for Astro, Next.js, SvelteKit, and Vite-React; Added test fixtures for Next.js CSP and Turborepo configurations; Added test fixtures for Next.js app router patterns; Added test fixtures for TanStack Router and TanStack Start live mode; Added test fixtures for the Oracle engine; Added test infrastructure and coverage for engine binary detection, live server lifecycle, and utility functions; Expanded test coverage for build, signing, CI, and live-mode fixtures; Expanded test fixtures for live mode across modern frameworks and CSP configurations; Expanded test fixtures for visual anti-pattern detection; New live-mode E2E test infrastructure and agent helpers; Oracle test harness for the Rust engine binary.

The project now includes a Rust workspace (Cargo.toml/Cargo.lock) containing the core detection engine and supporting crates (foundation, core, detect, html, browser, live, etc.), replacing previous JavaScript-based implementations. To support this, platform-specific optional dependencies are added for the CLI (\@impeccable/cli-darwin-arm64\, \@impeccable/cli-darwin-x64\, \@impeccable/cli-linux-arm64\, \@impeccable/cli-linux-x64\, \@impeccable/cli-windows-x64\), which provide the compiled engine binaries for their respective operating systems and architectures.

(dependencies) · high confidence

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

• CAI 30 → 53 (+23.9)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 25 → 43 (+17.7)
• Architecture 99 (new)
• Maturity 63 → 67 (+3.8)
• Readiness 20 → 53 (+33.3)
• Security 50 → 64 (+13.3)
• Domain Modelling 97 (new)
• Accessibility 70 (new)

• (anonymous) (cognitive 123) (cli/engine/engines/static-html/css-cascade.mjs)
• (anonymous) (cognitive 20) (cli/engine/engines/regex/detect-text.mjs)
• (anonymous) (cognitive 25) (cli/engine/engines/static-html/css-cascade.mjs)
• (anonymous) (cognitive 30) (extension/background/service-worker.js)
• (anonymous) (cognitive 38) (cli/engine/browser/injected/index.mjs)
• (anonymous) (cyclomatic 22) (cli/engine/browser/injected/index.mjs)
• (anonymous) (cyclomatic 24) (extension/background/service-worker.js)
• (anonymous) (cyclomatic 57) (cli/engine/engines/static-html/css-cascade.mjs)
• Boundary-crossing change coupling: impeccable-config.mjs ↔ hook-lib.mjs (cli/lib/impeccable-config.mjs)
• Boundary-crossing change coupling: serve-question.mjs ↔ serve-question.mjs (.grok/skills/impeccable/scripts/serve-question.mjs)
• Boundary-crossing change coupling: serve-question.mjs ↔ serve-question.mjs (.grok/skills/impeccable/scripts/serve-question.mjs)
• Boundary-crossing change coupling: serve-question.mjs ↔ serve-question.mjs (.grok/skills/impeccable/scripts/serve-question.mjs)
• Boundary-crossing change coupling: serve-question.mjs ↔ serve-question.mjs (.kiro/skills/impeccable/scripts/serve-question.mjs)
• Boundary-crossing change coupling: serve-question.mjs ↔ serve-question.mjs (.kiro/skills/impeccable/scripts/serve-question.mjs)
• Boundary-crossing change coupling: serve-question.mjs ↔ serve-question.mjs (.kiro/skills/impeccable/scripts/serve-question.mjs)
• Boundary-crossing change coupling: serve-question.mjs ↔ serve-question.mjs (.kiro/skills/impeccable/scripts/serve-question.mjs)
• Boundary-crossing change coupling: serve-question.mjs ↔ serve-question.mjs (.kiro/skills/impeccable/scripts/serve-question.mjs)
• Boundary-crossing change coupling: serve-question.mjs ↔ serve-question.mjs (.kiro/skills/impeccable/scripts/serve-question.mjs)
• Dimension evaluation failed
• FileTooLong: agents/llm-agent.mjs (tests/live-e2e/agents/llm-agent.mjs)
• …and 276 more

• (anonymous) (cognitive 20) (crates/cli/src/component_fonts.js)
• (anonymous) (cognitive 27) (crates/live/src/svelte_bridge_helper.mjs)
• (anonymous) (cognitive 31) (extension/background/service-worker.js)
• (anonymous) (cognitive 33) (extension/background/service-worker.js)
• (anonymous) (cognitive 41) (crates/cli/src/component_isolation.js)
• (anonymous) (cognitive 81) (browser-bundle/60-offscreen.js)
• (anonymous) (cyclomatic 18) (crates/live/src/svelte_bridge_helper.mjs)
• (anonymous) (cyclomatic 18) (extension/background/service-worker.js)
• (anonymous) (cyclomatic 19) (crates/cli/src/component_fonts.js)
• (anonymous) (cyclomatic 27) (extension/background/service-worker.js)
• (anonymous) (cyclomatic 39) (crates/cli/src/component_isolation.js)
• (anonymous) (cyclomatic 68) (browser-bundle/60-offscreen.js)
• (anonymous) (cyclomatic 94) (extension/content/content-script.js)
• (anonymous)::analyzeCandidate (cognitive 17) (extension/content/content-script.js)
• (anonymous)::drive (cognitive 19) (extension/content/content-script.js)
• (anonymous)::layers (cognitive 25) (crates/cli/src/asset_capture.js)
• (anonymous)::layers (cyclomatic 18) (crates/cli/src/asset_capture.js)
• (anonymous)::scan (cognitive 56) (crates/cli/src/asset_capture.js)
• (anonymous)::scan (cyclomatic 33) (crates/cli/src/asset_capture.js)
• (anonymous)::suppressMany (cognitive 31) (crates/cli/src/asset_capture.js)
• …and 1523 more

• 300 commits — 223 feature/other, 77 fixes

• skill/scripts — 69 commits
• .agents/skills — 39 commits
• (root) — 26 commits
• crates/live — 20 commits
• skill/reference — 14 commits
• .agent/skills — 13 commits
• cli/engine — 13 commits
• docs/COMP-FIDELITY.md — 12 commits
• (repo) — 11 commits
• tests/oracle — 10 commits
• crates/cli — 8 commits
• crates/context — 7 commits
• scripts/lib — 7 commits
• .github/workflows — 6 commits
• tests/skill-behavior — 6 commits
• crates/skills — 5 commits
• cli/bin — 4 commits
• crates/hook — 4 commits
• skill/SKILL.src.md — 3 commits
• scripts/test-suites.mjs — 2 commits

• fix: COMP-FIDELITY: ninth sweep (sol, artifact fix confirmed) and tenth sweep (opus confirmation on the rebased branch)
• fix: Fix Claude non-interactive skill activation (#738)
• fix: Fix Codex skill version metadata (#703)
• fix: Fix Next.js 16 CSP and parent hook discovery (#710)
• fix: Fix OpenCode slash command bridge (#483)
• fix: Fix PRODUCT schema drift (#688)
• fix: Fix Windows CSP candidate path normalization (#778)
• fix: Fix concept seed under symlinked installs (#686)
• fix: Fix detector URL scans and advisory handling (#709)
• fix: Fix flat type hierarchy false positives (#702)
• fix: Fix live cleanup races with framework HMR (#695)
• fix: Fix live script response encoding (#690)
• fix: Fix nested workspace gitignore patterns (#844)
• fix: Fix per-app design resolution in Rust hooks (#781)
• fix: Fix plugin script path resolution (#535)
• fix: Fix prompt embedding for install paths with spaces (#676)
• fix: Fix radius var fallback detection (#687)
• fix: Fix silent launcher setup failures (#788)
• fix: Fix skill subcommand help handling (#708)
• fix: Fix skill workflow regression coverage (#783)
• …and 280 more

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

pbakaus/impeccable 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.