@apptoolkit/harness 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,58 @@
-# Temporary Holding Version
+# Model-agnostic working practice source archive
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The user approved the common policy and all 37 workflow families. Start with the [tool and technology audit](llm/HARNESS-TOOL-AUDIT.md), [workflow catalog](llm/HARNESS-FLOWS-REVIEW.md) and [accepted user decisions](docs/harness-user-decisions.md).
+
+The [personal code style profile](src/author-style/README.md) includes the recovered writing rules, independent Biome installation and commands for verifying edited TypeScript.
+
+The product source is in [`src/harness/`](src/harness/), the author style source is in [`src/author-style/`](src/author-style/) and the acquisition utilities are in [`src/acquisition/`](src/acquisition/). The [development and local installation guide](docs/harness-release-verification.md#first-installation-in-this-repository) explains how to try the unpublished package in this repository. The [`llm/` catalog](llm/README.md) also documents the development commands.
+
+Develop and build with Bun. The npm artifact runs through `npx` or `bunx`, and `rtk proxy bun run build:harness:native` compiles the installer into a host executable for direct use.
+
+This workspace collects the original rules, writing guidance, workflows, prompts, tooling, project knowledge, and historical evidence from the user's selected projects. The first phase preserves raw material. Synthesis is a later phase.
+
+- [Intake and decisions](docs/intake.md)
+- [Raw acquisition index](raw/2026-11-04/README.md)
+- [Coverage and limitations](docs/coverage.md)
+- [Proposed gradual processing plan](docs/processing-plan.md)
+- [Derived coverage workspace](processing/README.md)
+- [Completed stage 1 coverage](docs/stage1-coverage.md)
+- [Stage 2 writing and communication pilot](docs/stage2-pilot.md)
+- [Stage 2 second extraction batch](docs/stage2-batch2.md)
+- [Stage 2 third extraction batch](docs/stage2-batch3.md)
+- [Stage 2 fourth extraction batch](docs/stage2-batch4.md)
+- [Stage 2 fifth extraction batch](docs/stage2-batch5.md)
+- [Stage 2 sixth extraction batch](docs/stage2-batch6.md)
+- [Stage 2 seventh extraction batch](docs/stage2-batch7.md)
+- [Stage 2 eighth extraction batch](docs/stage2-batch8.md)
+- [Stage 2 ninth extraction batch](docs/stage2-batch9.md)
+- [Stage 2 continuous extraction, first checkpoint](docs/stage2-continuous01.md)
+- [Stage 2 continuous extraction, second checkpoint](docs/stage2-continuous02.md)
+- [Stage 2 continuous extraction, third checkpoint](docs/stage2-continuous03.md)
+- [Stage 2 continuous extraction, fourth checkpoint](docs/stage2-continuous04.md)
+- [Stage 2 continuous extraction, fifth checkpoint](docs/stage2-continuous05.md)
+- [Stage 2 continuous extraction, sixth checkpoint](docs/stage2-continuous06.md)
+- [Stage 2 continuous extraction, seventh checkpoint](docs/stage2-continuous07.md)
+- [Stage 2 continuous extraction, eighth checkpoint](docs/stage2-continuous08.md)
+- [Stage 2 primary PDF source integration](docs/stage2-primary-pdf.md)
+- [Stage 2 continuous extraction, ninth checkpoint](docs/stage2-continuous09.md)
+- [Stage 2 continuous extraction, tenth mixed source checkpoint](docs/stage2-continuous10.md)
+- [Stage 2 continuous extraction, eleventh checkpoint](docs/stage2-continuous11.md)
+- [Tool catalog](llm/README.md)
+
+Acquired source files are evidence. They do not govern this workspace and must not be executed.
+
+The accepted C22 baseline has 30,454 provisional passage groups and 1,984 unexecuted procedures across 30 text streams, one PDF family and five archive families. Stage 2 remains active. Standalone references, captures and fixtures retain traceable context. Later stages compare duplicates and conflicts and develop portable guidance. [C22 report](docs/stage2-continuous22.md) · [Current queue](processing/stage2-completion-2026-11-04-v1/post-C22-source-review-queue-v2.json) · [C21 final receipt](processing/stage2-completion-2026-11-04-v1/validation/twenty-first-pass-final-closure-v1.json)
+
+## Earlier Stage 2 source checkpoint
+
+C24 has 31,022 accepted provisional passage groups, 2,081 unexecuted procedures and 1,544 refined source questions. The source and context queues remain open. Follow the [C24 report](docs/stage2-continuous24.md) and [current exact resume queue](processing/stage2-completion-2026-11-04-v1/post-C24-source-review-queue-v1.json). The [C23 report](docs/stage2-continuous23.md) retains the preceding checkpoint. No model-agnostic guidance has been adopted.
+
+## Current Stage 2 continuation
+
+C26 had 31,128 independently reviewed provisional passage groups, 2,135 unexecuted procedures and 1,544 refined source questions. The corrected C24 report and queue supersede the corresponding C24 navigation above. [C26 report](docs/stage2-continuous26.md) · [C26 source queue](processing/stage2-completion-2026-11-04-v1/post-C26-source-review-queue-v1.json) · [Corrected C24 report](docs/stage2-continuous24-v2.md) · [Corrected C24 queue](processing/stage2-completion-2026-11-04-v1/post-C24-source-review-queue-v2.json)
+
+C62 has 130,975 independently reviewed provisional groups, 13,744 unexecuted procedures, 1,558 refined source questions and 962 separately typed source contexts. Stage 2 remains open. [C62 report](docs/stage2-continuous62.md) · [Current source queue](processing/stage2-completion-2026-11-04-v1/post-C62-source-review-queue-v1.json) · [C61 report](docs/stage2-continuous61.md)
+
+## Current Stage 2 scope
+
+The user narrowed Stage 2 to an inventory of their decisions and mechanisms for working with LLMs. Start with the focused inventory and its source links. C62 remains the last accepted broader source checkpoint and supplies archival evidence. [Focused LLM working practices](docs/intake.md#focused-llm-working-practices) · [C62 report](docs/stage2-continuous62.md)

package/dist/bun/native/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AppToolkit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bun/native/README.md

@@ -0,0 +1,33 @@
+# AppToolkit Harness
+
+AppToolkit Harness installs project guidance, deterministic verification tools and 37 reusable engineering workflows for Codex, Claude Code and OpenCode. It supports new projects, existing repositories and a shared harness for related repositories.
+
+Use macOS or Linux with Bun 1.4.2 or later, or Node.js 24 or later with npm. Use Git for versioned projects and RTK for project tooling. Run the installer from the target directory using one of these commands.
+
+```sh
+rtk proxy bunx --bun @apptoolkit/harness install
+rtk proxy npx @apptoolkit/harness install
+```
+
+`bunx --bun` selects Bun even when Node.js is absent. Plain `bunx` also works when Node.js is on `PATH`.
+
+Review the proposed files, then select which agents, repositories and optional services to configure. Open the same directory in your agent and run `$apptoolkit init` in Codex or `/apptoolkit init` in Claude Code or OpenCode. The installed `llm/HARNESS.md` is the shared entry point.
+
+In a directory of related repositories, start the agent in the parent directory. The central harness keeps shared decisions and scoped repository context. Use `$apptoolkit add repo <path>` or `/apptoolkit add repo <path>` after cloning another repository. Repositories can keep their own guidance and toolchain.
+
+To preview an installation in a noninteractive session, inspect the target and supply the explicit choices.
+
+```sh
+rtk proxy bunx --bun @apptoolkit/harness inspect --root /absolute/workspace --json
+rtk proxy bunx --bun @apptoolkit/harness install --root /absolute/workspace --hosts codex,claude,opencode --local --repo-mode .=local --plan --json
+```
+
+Use `--yes` in place of `--plan` to apply a reviewed noninteractive plan. Select the workspace mode separately from each Git repository's generated files. Local mode uses the repository's `info/exclude` metadata for the planned files. Use `--repo-mode <path>=local|versioned` for each selected Git repository.
+
+Use `rtk proxy bunx --bun @apptoolkit/harness@latest update --plan --json` or `rtk proxy npx @apptoolkit/harness@latest update --plan --json` to preview a release update. The updater checks managed files against the installation receipt. Resolve reported conflicts before applying the update. Keep project decisions in the installed local profile, and review the affected paths and version before applying.
+
+Plane and Penpot are separate opt-ins. To make a provider available after installation, preview an update with `--enable-service plane` or `--enable-service penpot`, apply it, and complete the project connection through `init`. The installed runbooks explain instance setup, private credentials, authorization and readiness checks. Snapshot verification requires a versioned harness and project-level opt-in. Use Bun to install the isolated Biome dependency before first using the author style profile.
+
+The installed local CLI reads the workflow index, retrieves one workflow at a time and checks Markdown against a local document policy. See `llm/HARNESS.md` for the exact commands. The agent records which operations are configured and which were verified in the current environment.
+
+Distributed under the MIT license.

package/dist/bun/native/harness

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: package/dist/bun/native/harness
+size: 63267186 bytes
+sha256: 073a12fd1b3f9c7430961f47079e444d46cd0be30116156c7677beaba0660070

package/dist/bun/native/payload/HARNESS.md

@@ -0,0 +1,21 @@
+# AppToolkit Harness
+
+Use this index when adopting a project or opening a fresh agent session. Resolve the project, read its applicable rules, and open the smallest workflow that matches the request.
+
+| Need | Start here |
+| --- | --- |
+| Find the procedure for a natural request | [Workflow index](harness/WORKFLOWS.md) |
+| Start a new feature or an unresolved change | [W16 Feature definition](harness/workflows/W16.md) |
+| Adopt, initialize or update this installation | [W20 Adoption](harness/workflows/W20.md) |
+| Resolve repositories, services and project conventions | [Project guide](harness/PROJECT.md) |
+| Check permissions, engineering rules and learning | [Operating policy](harness/POLICY.md) |
+| Audit a claim or independently review code | [Independent review](harness/REVIEW.md) |
+| Prepare a decision, work unit or checkpoint | [Templates](harness/TEMPLATES.md) |
+| Verify coverage against an explicit source inventory | [W23 Verification](harness/workflows/W23.md) |
+| Verify authored TypeScript without a compatible project Biome configuration | [Style tools](author-style/README.md) |
+
+Begin with the installed workspace and project records for the active root. Apply the nearest repository guidance as well as shared decisions relevant to that repository. Use source maps to locate the relevant sections. For a natural request such as “Give me my pending list” or “Dame mi lista de pendientes”, open only [W01](harness/workflows/W01.md), resolve its target and use the project's authorized sources.
+
+Run `rtk proxy bun --no-env-file llm/harness/runtime/harness.mjs context llm/HARNESS.md` from the installation root to list heading locators without returning the body. If only Node.js is available, replace `bun --no-env-file` with `node` in installed runtime commands. Add `--section line:1` with the locator reported for the desired heading. An exact title or anchor also works when unique. Select a line locator for repeated titles. The reader opens regular project-relative Markdown files, rejects protected locations and symbolic links, and returns a bounded section with its source line range.
+
+Open an indexed workflow directly with `rtk proxy bunx --bun @apptoolkit/harness workflow W01` or `rtk proxy npx @apptoolkit/harness workflow W01`. Use [W21](harness/workflows/W21.md) to plan local source-map protection and [W23](harness/workflows/W23.md) to check a fresh LCOV report.

package/dist/bun/native/payload/author-style/README.md

@@ -0,0 +1,56 @@
+# Personal code style
+
+Use this profile whenever an agent writes or changes authored TypeScript in a project without an applicable Biome configuration. It supplies a pinned Biome dependency, configuration, structural lint rules and a small TypeScript parser supplement. The tool reads only the explicitly selected source files for its supplementary checks and never writes target files.
+
+- [Writing rules](#writing-rules): Read before editing code.
+- [Deterministic checks](#deterministic-checks): Select an appropriate profile.
+- [Install and run](#install-and-run): Run after each code edit batch and before handoff. See the [checker map](check.llm.md) when maintaining the tool.
+- [Evidence and precedence](#evidence-and-precedence): Determine what is personal, historical or specific to a project.
+
+## Writing rules
+
+1. Write code in execution order. Name intermediate values when nesting hides decisions. Use explicit guards and braces, keep related steps together and separate preparation, reads, decisions, writes and returns when they serve different purposes. Keep a simple expression concise.
+2. Define domain contracts before behavior. Keep a schema and its inferred types together and validate untrusted data before it enters domain logic. Reuse the accepted validation contract. Ask before adding Zod to a target that does not have it. Use explicit projections at public boundaries.
+3. Keep transport and framework adapters focused. Separate domain decisions from persistence and wire explicit dependencies. Preserve the project's established class, module or functional organization. In classes, order static properties and methods before the constructor and instance properties and methods after it. Put private or protected members before public members in the corresponding group. Prefer constructor parameter properties for retained values and keep related operations in workflow order.
+4. Use descriptive names and structure to explain behavior. Preserve rationale in the project's decision, ticket or review record. Keep a cause and useful context when operations fail. Prove guards, recovery and failure behavior through focused tests. Do not copy historical workarounds or weaken types to make checks pass.
+5. Scope component rules to reusable React components. Prefer a named PascalCase `const`, explicit `FC` props and a default export when compatible with local rules. Keep props near their component and keep inline event callbacks to a single simple call. Use descriptive local `handle…` names. Treat framework entry points, generic components and library-owned wrappers according to their actual contract.
+
+## Deterministic checks
+
+| Area | Enforcement |
+| --- | --- |
+| Format | Biome uses two spaces, LF, a 120-column line width, single quotes in TypeScript, double quotes in JSX, semicolons, trailing commas and parenthesized arrow parameters. |
+| Structure | Biome and the bundled Grit plugins check braces, explicit class accessibility, supported member-order inversions, multiline or branching arrow bodies and increment/decrement operators. The TypeScript supplement checks statement phase boundaries and class member separation, keeping overloads grouped. |
+| Types and source | Biome rejects explicit `any`, non-null assertions, selected suppression directives and configured unsafe type patterns. Grit rejects explicit `unknown` type nodes. The TypeScript supplement checks double assertions, explanatory comments and top-level inferred types derived directly from a same-file schema via a recognized Zod import. It preserves parsed TypeScript reference directives and exact SQL markers before supported tagged templates. |
+| `react` | Includes the common checks plus selected JSX components, exports, `FC` typing, inline event call shape and local event names. It recognizes direct imported React `memo` and `forwardRef`. Select reusable component files. Other wrappers, arbitrary aliases and semantic event binding still need review. |
+| `sql` | Includes the common checks plus a lexical check for supported templates with a direct `sql` tag. Select it only where the project's `sql` tag is PostgreSQL. It does not resolve aliases or parse the SQL dialect. Unsupported fragments remain outside the check. |
+
+Keep the native type checker, focused behavior tests, independent technical audit and separate code review. Static checks do not prove meaningful names, correct schema ownership, safe public exposure, awaited authorization, rejection handling, transaction semantics or test adequacy. A successful check reports a result for the selected files and patterns. It does not establish whole-project coverage.
+
+## Install and run
+
+Use the installed `llm/author-style/` directory in the adopting project. Keep its package manifest and `bun.lock` together. Run these commands from the adopting project's root with RTK and Bun 1.4.2 or later.
+
+```text
+rtk proxy bun install --cwd llm/author-style --frozen-lockfile --ignore-scripts
+rtk proxy bun run --cwd llm/author-style check --root /absolute/project path/to/changed.ts
+```
+
+The Bun install command installs the isolated verifier and its platform binary inside `llm/author-style/`. Keep the application's own dependencies, lockfile and package manager. Use explicit paths under the actual project root. Quote paths containing spaces and pass `--` before paths beginning with a hyphen. Supported inputs are `.ts`, `.tsx`, `.mts` and `.cts`. A selection can include new and existing files. The verifier reads the whole selected file, so keep inherited violations separate and do not reformat unrelated code. The command rejects symlinks, known generated or dependency directories, generated headers and out-of-root paths.
+
+```text
+rtk proxy bun run --cwd llm/author-style check --root /absolute/project --profile react src/Panel.tsx
+rtk proxy bun run --cwd llm/author-style check --root /absolute/project --profile sql src/queries.ts
+rtk proxy bun run --cwd llm/author-style check --root /absolute/project --lint-only src/service.ts
+rtk proxy bun run --cwd llm/author-style test
+```
+
+For an existing project, follow its own rules and tools first. The verifier refuses a selected file when it finds a native `biome.json` or `biome.jsonc` in its directory or an ancestor. If another formatter is authoritative and its lint policy is compatible, select `--lint-only` to omit personal formatting and spacing. If the existing lint policy conflicts, follow the project and record the difference. The verifier does not select or replace an ESLint, Prettier or other configuration on its own. Native Biome warnings, including an oversized selected file, cause a failed check. A native failure prevents the supplementary checks from running. Resolve the reported cause and rerun the same selection.
+
+Record the selected paths and result in the normal verification evidence. Add this instruction to the adopting agent's entry point or shared verification instructions. Every agent should run the same command after a code edit batch and before delivery. The package installs no editor, Git, CI or model-specific hook.
+
+> After each code edit batch and before handoff, run the project's applicable Biome checks. When no applicable Biome configuration exists, run the compatible profile in `llm/author-style/README.md` on the edited TypeScript files. Use the project's established formatter and lint policy first. Record the result with the other verification evidence.
+
+## Evidence and precedence
+
+Use the target project rules where established. Document and test a mechanical correction before changing a shared rule.

package/dist/bun/native/payload/author-style/biome-core.json

@@ -0,0 +1,57 @@
+{
+  "root": true,
+  "plugins": [
+    "./plugins/class-member-order.grit",
+    "./plugins/explicit-arrow-body.grit",
+    "./plugins/explicit-source-constructs.grit"
+  ],
+  "formatter": {
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineEnding": "lf",
+    "lineWidth": 120
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "jsxQuoteStyle": "double",
+      "quoteProperties": "asNeeded",
+      "trailingCommas": "all",
+      "semicolons": "always",
+      "arrowParentheses": "always",
+      "bracketSameLine": false,
+      "bracketSpacing": true
+    }
+  },
+  "assist": {
+    "enabled": false
+  },
+  "linter": {
+    "rules": {
+      "recommended": false,
+      "correctness": {
+        "noUnusedImports": "error",
+        "noUnusedPrivateClassMembers": "error",
+        "noUnusedVariables": "error"
+      },
+      "nursery": {
+        "noFloatingPromises": "error",
+        "noMisusedPromises": "error",
+        "noUnsafeTypeAssertion": "error"
+      },
+      "style": {
+        "noNonNullAssertion": "error",
+        "useBlockStatements": "error",
+        "useConsistentMemberAccessibility": {
+          "level": "error",
+          "options": { "accessibility": "explicit" }
+        },
+        "useImportType": "error"
+      },
+      "suspicious": {
+        "noExplicitAny": "error",
+        "noTsIgnore": "error"
+      }
+    }
+  }
+}

package/dist/bun/native/payload/author-style/biome-react.json

@@ -0,0 +1,9 @@
+{
+  "extends": ["./biome-core.json"],
+  "plugins": [
+    "./plugins/class-member-order.grit",
+    "./plugins/react-arrow-body.grit",
+    "./plugins/explicit-source-constructs.grit",
+    "./plugins/event-handler-names.grit"
+  ]
+}

package/dist/bun/native/payload/author-style/biome-sql.json

@@ -0,0 +1,9 @@
+{
+  "extends": ["./biome-core.json"],
+  "plugins": [
+    "./plugins/class-member-order.grit",
+    "./plugins/explicit-arrow-body.grit",
+    "./plugins/explicit-source-constructs.grit",
+    "./plugins/sql-style.grit"
+  ]
+}

package/dist/bun/native/payload/author-style/bun.lock

@@ -0,0 +1,37 @@
+{
+  "lockfileVersion": 2,
+  "configVersion": 0,
+  "workspaces": {
+    "": {
+      "name": "harness-author-style",
+      "devDependencies": {
+        "@biomejs/biome": "2.5.15",
+        "typescript": "5.9.3",
+        "zod": "4.6.7",
+      },
+    },
+  },
+  "packages": {
+    "@biomejs/biome": ["@biomejs/biome@2.5.15", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.5.15", "@biomejs/cli-darwin-x64": "2.5.15", "@biomejs/cli-linux-arm64": "2.5.15", "@biomejs/cli-linux-arm64-musl": "2.5.15", "@biomejs/cli-linux-x64": "2.5.15", "@biomejs/cli-linux-x64-musl": "2.5.15", "@biomejs/cli-win32-arm64": "2.5.15", "@biomejs/cli-win32-x64": "2.5.15" }, "bin": { "biome": "bin/biome" } }, "sha512-WZTW4slm/pdkh92K6t/3aEN++44JD1PQ7squ7RCMLI1flHGl43DVOIGXvCjHiZgBMO1V4uYxoFNtqrIA4qGuIQ=="],
+
+    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.5.15", "", { "os": "darwin", "cpu": "arm64" }, "sha512-BZVzFhJ/mUvTLMYbc9x6el0o2Uv5zP7bACYyhFb6fSc1giroXm7PL0a5KqMJ9F+/BnkYRjagD/ROSDVOZ6eapg=="],
+
+    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.5.15", "", { "os": "darwin", "cpu": "x64" }, "sha512-V5Kw63V+fVGNFhFrizDxMbGXAzZCh8kYzJpy3GI6gTapWDg7bZK9oYC9CbVgQSEdTnupz0U5Efz8Ev+5vdBBXw=="],
+
+    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.5.15", "", { "os": "linux", "cpu": "arm64" }, "sha512-XaG7P7eeSLYETD3K9grfB0mQmpLQZjygdbsxekWBJAg4am79fGAtRpfRyNnTvXB2fZFNnJZG3nXm7HBat0+VUw=="],
+
+    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.5.15", "", { "os": "linux", "cpu": "arm64" }, "sha512-tGzZUTcJCV7tj5Adh/Gn6nR4MycqA3iohq2LEcrarAgRBkU0h0OKd2UzCRkOsOYOuUGaUJb4YmqRqyy2feGGSw=="],
+
+    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.5.15", "", { "os": "linux", "cpu": "x64" }, "sha512-xE4iEW/3LqlYj9GFgGrFsFSH51dEEpUbYWBfeOv0q87WkUDxK2o/HhreSb7qMJqck70RVM6Lg96hgedcAYcOkA=="],
+
+    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.5.15", "", { "os": "linux", "cpu": "x64" }, "sha512-IlxUcyxilVGPsE008x13pWdkTbU3nQpP2i9b5UrbOYj6goBkKsRX1XB7yJLcV+O1H9LBchIIm4adOaVLZBX0ZQ=="],
+
+    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.5.15", "", { "os": "win32", "cpu": "arm64" }, "sha512-2kPKzhNlm8C+Ru3GcO0Me2ODkCBLrVOUNuyi84RJyWDVKAA4+Kjj3jMjL938lF6BRfvltC4vB2nPY9SvN51Ovg=="],
+
+    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.5.15", "", { "os": "win32", "cpu": "x64" }, "sha512-yAzh4UqEImV6Hcy0zjUqNfJAsUhoD64FBQCdTG8Md/Z2wQeVP/ZmJ3XRYAs1g8J9fjTFyl2fCtc5FB5til47+g=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "zod": ["zod@4.6.7", "", {}, "sha512-g8W2D2kU6a8untc053fX1uVBKzM7yqAxW/3zwk83+6RyF2+SKOuV+c0wBDhUwzV1PaGapmZH+rmcUzPf+3CGwg=="],
+  }
+}

package/dist/bun/native/payload/author-style/check.llm.md

@@ -0,0 +1,17 @@
+# Author style checker map
+
+- [Inputs and project authority](#inputs-and-project-authority)
+- [Native and parser checks](#native-and-parser-checks)
+- [Verification and recovery](#verification-and-recovery)
+
+## Inputs and project authority
+
+Start in `check.ts` at `checkFiles`. The request schema describes the project root, selected files, profile and mode. `targetRelativePath` establishes containment and `configuredBiome` detects local Biome configuration. See [install and run](README.md#install-and-run) for adoption, supported files and exclusions.
+
+## Native and parser checks
+
+The `configurations` map selects the isolated Biome configuration. The checker uses the locked package, clears `BIOME_BINARY`, and starts Bun without dotenv loading or automatic installs. It propagates the native status. `findSourcePolicyIssues`, `findSpacingIssues`, `findMemberSpacingIssues` and `findReactModuleIssues` inspect the selected source without writing. The [check matrix](README.md#deterministic-checks) lists supported patterns and separate review boundaries.
+
+## Verification and recovery
+
+`check.test.ts` covers installation layout, native and project authority checks, selected inputs and supplementary results. The individual parser test files cover exact constructs and boundaries. See [install and run](README.md#install-and-run) for the test command. Do not treat a skipped, failed or interrupted check as evidence that selected code passed.

package/dist/bun/native/payload/author-style/check.test.llm.md

@@ -0,0 +1,17 @@
+# Checker integration test map
+
+- [Installed layout and source selection](#installed-layout-and-source-selection)
+- [Native profiles and policy](#native-profiles-and-policy)
+- [Failure paths](#failure-paths)
+
+## Installed layout and source selection
+
+`runs when the profile is installed under the adopting project llm directory` covers private configuration discovery. `uses the isolated formatter and linter on exact paths outside the harness without writing` covers exact file names, unselected files and byte preservation.
+
+## Native profiles and policy
+
+`enforces core types, explicit updates, braces, branches and class layout` exercises the real engine and a rejected environment override. `uses the pinned Biome launcher when the target dotenv defines another binary` covers Bun subprocess isolation. `uses separately selected React and tagged SQL checks` distinguishes profile findings from the common configuration.
+
+## Failure paths
+
+`fails a mixed selection when Biome cannot check an oversized file` protects against partial checks reported as success. `refuses existing configurations, generated files, symlinks and an empty file selection` checks scope and authority. Supplementary parser cases have their own focused test files.

package/dist/bun/native/payload/author-style/check.test.ts

@@ -0,0 +1,238 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const checker = fileURLToPath(new URL('check.ts', import.meta.url));
+
+function executeFrom(entry: string, root: string, args: string[], env = process.env) {
+  const result = spawnSync(process.execPath, [entry, '--root', root, ...args], { encoding: 'utf8', env });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return result;
+}
+
+function execute(root: string, ...args: string[]) {
+  return executeFrom(checker, root, args);
+}
+
+test('runs when the profile is installed under the adopting project llm directory', (context) => {
+  const root = mkdtempSync(join(tmpdir(), 'harness-style-'));
+
+  context.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const profile = join(root, 'llm', 'author-style');
+
+  mkdirSync(profile, { recursive: true });
+
+  const packageDirectory = fileURLToPath(new URL('.', import.meta.url));
+
+  for (const file of [
+    'check.ts',
+    'source-policy.ts',
+    'spacing.ts',
+    'member-spacing.ts',
+    'react-module.ts',
+    'package.json',
+    'biome-core.json',
+    'plugins',
+  ]) {
+    cpSync(join(packageDirectory, file), join(profile, file), { recursive: true });
+  }
+
+  symlinkSync(join(packageDirectory, 'node_modules'), join(profile, 'node_modules'), 'dir');
+  writeFileSync(join(root, 'entry.ts'), 'export const sample = true;\n');
+
+  const result = executeFrom(join(profile, 'check.ts'), root, ['entry.ts']);
+
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /Checked 1 file/);
+});
+
+test('uses the isolated formatter and linter on exact paths outside the harness without writing', (context) => {
+  const root = mkdtempSync(join(tmpdir(), 'harness-style-'));
+
+  context.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const clean = join(root, 'has spaces.ts');
+  const poorlyFormatted = "export const label='one'\n";
+
+  writeFileSync(clean, poorlyFormatted);
+  writeFileSync(join(root, 'unselected.ts'), 'export const counter: any = 0;\n');
+
+  const failure = execute(root, 'has spaces.ts');
+
+  assert.equal(failure.status, 1);
+  assert.match(failure.stderr, /Formatter would have printed/);
+  assert.equal(readFileSync(clean, 'utf8'), poorlyFormatted);
+
+  const lintOnly = execute(root, '--lint-only', 'has spaces.ts');
+
+  assert.equal(lintOnly.status, 0, lintOnly.stderr);
+
+  writeFileSync(clean, 'export const label = `line\n// @generated\nline`;\n');
+
+  const success = execute(root, clean);
+
+  assert.equal(success.status, 0, success.stderr);
+  assert.match(success.stdout, /Checked 1 file/);
+});
+
+test('enforces core types, explicit updates, braces, branches and class layout', (context) => {
+  const root = mkdtempSync(join(tmpdir(), 'harness-style-'));
+
+  context.after(() => rmSync(root, { recursive: true, force: true }));
+
+  writeFileSync(
+    join(root, 'shape.ts'),
+    [
+      'export class Selection {',
+      '  public choose(flag: boolean): number {',
+      '    let count = 1;',
+      '    if (flag) count++;',
+      '    return count;',
+      '  }',
+      '  public static create(): Selection {',
+      '    return new Selection();',
+      '  }',
+      '}',
+      'export const resolve = (value: boolean): string => (value ? "a" : "b");',
+      'export const loose: any = 1;',
+      'export const ambiguous: unknown = 2;',
+    ].join('\n'),
+  );
+
+  const result = executeFrom(checker, root, ['--lint-only', 'shape.ts'], {
+    ...process.env,
+    BIOME_BINARY: process.execPath,
+  });
+
+  assert.equal(result.status, 1);
+  assert.match(result.stderr, /Use an explicit update/);
+  assert.match(result.stderr, /useBlockStatements/);
+  assert.match(result.stderr, /explicit return/);
+  assert.match(result.stderr, /class member order/i);
+  assert.match(result.stderr, /noExplicitAny/);
+  assert.match(result.stderr, /Use an explicit domain type/);
+});
+
+test('uses the pinned Biome launcher when the target dotenv defines another binary', (context) => {
+  const root = mkdtempSync(join(tmpdir(), 'harness-style-'));
+
+  context.after(() => rmSync(root, { recursive: true, force: true }));
+
+  writeFileSync(join(root, '.env'), `BIOME_BINARY=${process.execPath}\n`);
+  writeFileSync(join(root, 'entry.ts'), 'export const sample = true;\n');
+
+  const result = execute(root, 'entry.ts');
+
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /Checked 1 file/);
+});
+
+test('uses separately selected React and tagged SQL checks', (context) => {
+  const root = mkdtempSync(join(tmpdir(), 'harness-style-'));
+
+  context.after(() => rmSync(root, { recursive: true, force: true }));
+
+  writeFileSync(join(root, 'Panel.tsx'), 'export default function Panel() { return <p>Hello</p>; }\n');
+  writeFileSync(join(root, 'Card.tsx'), 'const Card = () => <p>Hello</p>;\nexport default Card;\n');
+  writeFileSync(join(root, 'helper.ts'), 'export const UppercaseHelper = () => 1;\n');
+  writeFileSync(
+    join(root, 'query.ts'),
+    'export const find = (sql: (strings: TemplateStringsArray) => string) => sql`select id from records`;\n',
+  );
+
+  const core = execute(root, '--lint-only', 'Panel.tsx', 'query.ts');
+
+  assert.equal(core.status, 0, core.stderr);
+
+  const react = execute(root, '--profile', 'react', '--lint-only', 'Panel.tsx');
+
+  assert.equal(react.status, 1);
+  assert.match(react.stderr, /named const component/);
+
+  const arrow = execute(root, '--profile', 'react', '--lint-only', 'Card.tsx');
+
+  assert.equal(arrow.status, 1);
+  assert.match(arrow.stderr, /Annotate React arrow components/);
+
+  const helper = execute(root, '--profile', 'react', '--lint-only', 'helper.ts');
+
+  assert.equal(helper.status, 0, helper.stderr);
+
+  writeFileSync(
+    join(root, 'event.tsx'),
+    'export const view = <button onClick={() => { console.log("clicked"); }}>Go</button>;\n',
+  );
+
+  const plainEvent = execute(root, '--lint-only', 'event.tsx');
+
+  assert.equal(plainEvent.status, 0, plainEvent.stderr);
+
+  const reactEvent = execute(root, '--profile', 'react', '--lint-only', 'event.tsx');
+
+  assert.equal(reactEvent.status, 1);
+  assert.match(reactEvent.stderr, /inline JSX handler as one call expression/);
+
+  const sql = execute(root, '--profile', 'sql', '--lint-only', 'query.ts');
+
+  assert.equal(sql.status, 1);
+  assert.match(sql.stderr, /SQL keywords/i);
+});
+
+test('fails a mixed selection when Biome cannot check an oversized file', (context) => {
+  const root = mkdtempSync(join(tmpdir(), 'harness-style-'));
+
+  context.after(() => rmSync(root, { recursive: true, force: true }));
+  writeFileSync(join(root, 'small.ts'), 'export const sample = true;\n');
+  writeFileSync(join(root, 'large.ts'), `export const sample = '${'a'.repeat(1024 * 1024)}';\n`);
+
+  const result = execute(root, '--lint-only', 'small.ts', 'large.ts');
+
+  assert.equal(result.status, 1);
+  assert.match(result.stderr, /exceeds the configured maximum/);
+});
+
+test('refuses existing configurations, generated files, symlinks and an empty file selection', (context) => {
+  const root = mkdtempSync(join(tmpdir(), 'harness-style-'));
+
+  context.after(() => rmSync(root, { recursive: true, force: true }));
+
+  mkdirSync(join(root, 'app'));
+  writeFileSync(join(root, 'app', 'biome.jsonc'), '{}\n');
+  writeFileSync(join(root, 'app', 'module.ts'), 'export const sample = true;\n');
+  writeFileSync(join(root, 'generated.ts'), '// @generated\nexport const sample = true;\n');
+  symlinkSync(join(root, 'generated.ts'), join(root, 'linked.ts'));
+
+  const expected = [
+    { files: ['app/module.ts'], message: /project's configured Biome checks/ },
+    { files: ['generated.ts'], message: /instead of a generated artifact/ },
+    { files: ['linked.ts'], message: /instead of a symbolic link/ },
+    { files: ['../outside.ts'], message: /inside/ },
+    { files: [], message: /Supply the files you changed/ },
+  ];
+
+  for (const { files, message } of expected) {
+    const result = execute(root, ...files);
+
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, message);
+  }
+
+  const child = join(root, 'app', 'child');
+
+  mkdirSync(child);
+  writeFileSync(join(child, 'module.ts'), 'export const sample = true;\n');
+
+  const parentConfiguration = execute(child, 'module.ts');
+
+  assert.equal(parentConfiguration.status, 1);
+  assert.match(parentConfiguration.stderr, /project's configured Biome checks/);
+});