@cratis/pi 7.100.0 → 7.102.0

package/package/corpus/skills/cratis-ci-pipeline-performance/scripts/fixtures/runs.json

@@ -0,0 +1,102 @@
+[
+  {
+    "databaseId": 1001,
+    "event": "pull_request",
+    "headBranch": "feat",
+    "status": "completed",
+    "conclusion": "success",
+    "attempt": 1,
+    "createdAt": "2030-01-01T01:00:00Z",
+    "updatedAt": "2030-01-01T01:10:00Z"
+  },
+  {
+    "databaseId": 1002,
+    "event": "pull_request",
+    "headBranch": "feat",
+    "status": "completed",
+    "conclusion": "success",
+    "attempt": 1,
+    "createdAt": "2030-01-01T02:00:00Z",
+    "updatedAt": "2030-01-01T02:20:00Z"
+  },
+  {
+    "databaseId": 1003,
+    "event": "pull_request",
+    "headBranch": "feat",
+    "status": "completed",
+    "conclusion": "success",
+    "attempt": 1,
+    "createdAt": "2030-01-01T03:00:00Z",
+    "updatedAt": "2030-01-01T03:30:00Z"
+  },
+  {
+    "databaseId": 1004,
+    "event": "pull_request",
+    "headBranch": "feat",
+    "status": "completed",
+    "conclusion": "failure",
+    "attempt": 1,
+    "createdAt": "2030-01-01T04:00:00Z",
+    "updatedAt": "2030-01-01T04:05:00Z"
+  },
+  {
+    "databaseId": 1005,
+    "event": "pull_request",
+    "headBranch": "feat",
+    "status": "completed",
+    "conclusion": "cancelled",
+    "attempt": 1,
+    "createdAt": "2030-01-01T05:00:00Z",
+    "updatedAt": "2030-01-01T05:02:00Z"
+  },
+  {
+    "databaseId": 1006,
+    "event": "pull_request",
+    "headBranch": "feat",
+    "status": "completed",
+    "conclusion": "success",
+    "attempt": 2,
+    "createdAt": "2030-01-01T06:00:00Z",
+    "updatedAt": "2030-01-01T06:40:00Z"
+  },
+  {
+    "databaseId": 1007,
+    "event": "push",
+    "headBranch": "main",
+    "status": "completed",
+    "conclusion": "success",
+    "attempt": 1,
+    "createdAt": "2030-01-01T07:00:00Z",
+    "updatedAt": "2030-01-01T07:15:00Z"
+  },
+  {
+    "databaseId": 1008,
+    "event": "pull_request",
+    "headBranch": "feat",
+    "status": "completed",
+    "conclusion": "skipped",
+    "attempt": 1,
+    "createdAt": "2030-01-01T08:00:00Z",
+    "updatedAt": "2030-01-01T08:00:00Z"
+  },
+  {
+    "databaseId": 1009,
+    "event": "pull_request",
+    "headBranch": "feat",
+    "status": "in_progress",
+    "conclusion": "",
+    "attempt": 1,
+    "createdAt": "2030-01-01T09:00:00Z",
+    "updatedAt": "2030-01-01T09:01:00Z"
+  },
+  {
+    "databaseId": 1010,
+    "event": "pull_request",
+    "headBranch": "feat",
+    "status": "completed",
+    "conclusion": "success",
+    "attempt": 1,
+    "createdAt": "2030-01-01T10:00:00Z",
+    "updatedAt": "2030-01-01T10:25:00Z"
+  }
+]

package/package/corpus/skills/cratis-engineering-local-cross-repo-verification/LICENSE

@@ -0,0 +1,2 @@
+Copyright (c) Cratis. All rights reserved.
+Licensed under the MIT license. See LICENSE file in the canonical Cratis/AI repository for the full license text.

package/package/corpus/skills/cratis-engineering-local-cross-repo-verification/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: cratis-engineering-local-cross-repo-verification
+description: Proves lower-layer Cratis fixes in downstream repositories using local packages and images. Use when a lower-layer fix must be proven in a consumer, before the producer PR for a consumer bug, before requesting or waiting on a release, or when reproducing a consumer bug against lower-layer main. Not for single-repo changes, released-version pin bumps, CI changes, or shipping; use the ship-changes prompt for shipping and cratis-release-notes for release text.
+license: LICENSE
+compatibility: Bash and git on macOS or Linux; Windows through WSL. Requires the ecosystem tools used by the selected recipe.
+---
+
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Local cross-repository verification
+
+## Decide before waiting
+
+Use real locally built packages to prove a producer fix at its consumer's package
+boundary. A **producer** builds the changed library or image; a **consumer** is the
+downstream repository that reproduces the bug. Start before opening the producer
+PR whose purpose is that consumer bug, rather than publishing just to find out.
+Also use this loop to compare the consumer against lower-layer main.
+
+**Local verification replaces waiting, not shipping.** After local proof, release
+the producer through the normal authorized workflow and bump the consumer to the
+released version. Local feeds, pins and images never go into production or a PR.
+Single-repository work needs its own regression specs, not this overlay. Released
+pin updates use ordinary dependency maintenance; CI changes use the
+[github-actions rule](../../rules/github-actions.md). Shipping uses the
+[ship-changes prompt](../../prompts/ship-changes.prompt.md); release text uses
+[cratis-release-notes](../cratis-release-notes/SKILL.md).
+
+## Prepare
+
+Execute [scripts/cratis-local-packages.sh](scripts/cratis-local-packages.sh), not
+an improvised replacement. Run `bash "$local" <command> --help` for inputs and
+errors. Requires bash and git; add dotnet for NuGet, node and Yarn for npm, Docker
+for images, or the selected language toolchain. Check availability first:
+
+```bash
+local=/absolute/path/to/skill/scripts/cratis-local-packages.sh
+producer=/absolute/path/to/producer
+consumer=/absolute/path/to/consumer
+bash --version
+git --version
+command -v dotnet # substitute node/yarn/docker for the selected recipe
+```
+
+The helper works with macOS bash 3.2 and Linux; Windows requires WSL. Match kernel
+publish RID and image architecture to the consumer daemon: `linux-arm64` and
+`arm64`, or `linux-x64` and `amd64`. Do not claim performance equivalence from a
+Debug build or across architectures.
+
+Check disk space and preserve existing edits in both repositories. Use an isolated
+worktree when a build regenerates tracked output. Inspect the consumer's own CI
+commands before choosing the build, regression spec and full gate commands.
+
+## Copy this checklist
+
+- [ ] Reproduce the consumer bug and select its regression spec/app action.
+- [ ] Generate one stamp; build and pack the producer's full dependency closure.
+- [ ] If needed, publish the kernel and assets, then build a matching local image.
+- [ ] Activate the consumer overlay and select the local image.
+- [ ] Build the consumer, run its regression specs/app action and required gates.
+- [ ] On failure, diagnose, fix the producer, create a distinct stamp and repeat.
+- [ ] Run `check` before every consumer commit and push, and on the producer.
+- [ ] Restore overlays, unset environment overrides, and run `check` again.
+- [ ] Review stamp-scoped `clean` dry-run targets, then apply cleanup.
+
+### 1. Stamp
+
+```bash
+stamp=$(bash "$local" stamp "$producer")
+```
+
+Format: `<next-patch>-local.<12-digit-UTC-minute>.g<sha7>`, based on the highest reachable
+`vX.Y.Z` tag. Next-patch prereleases sort above the existing release; arbitrary
+`0.0.0-local` versions can violate transitive minimums and cause **NU1605**
+downgrades. Confirm tags cover the consumer's released constraints. With no tag,
+the helper warns and falls back to a base that must be checked before proceeding.
+The `g` prefix keeps even an all-digit SHA nonnumeric in SemVer.
+Use the identical stamp for packages and images. A changed build needs a distinct
+stamp; do not overwrite a cached version (the minute and commit determine it).
+
+### 2. Build and pack
+
+Run the producer's CI-equivalent build/specs first. NuGet packing builds in Release:
+
+```bash
+bash "$local" pack-nuget "$producer" "$stamp" path/to/producer.slnx
+```
+
+For npm, complete the repository build before
+`bash "$local" pack-npm "$producer" "$stamp"`. Pass: nonzero package count and
+exit `0`. Inspect package dependencies: every locally changed dependency ID must
+resolve to the stamp, not a published fallback. Chronicle's client solution filter
+can omit `Cratis.Chronicle.CodeAnalysis`; pack its code-analysis package project
+separately. A successful pack alone does not prove dependency closure.
+
+### 3. Build an image when needed
+
+Follow the kernel recipe below before building; it needs published binaries and
+Workbench `wwwroot`. From the producer root, for the selected architecture:
+
+```bash
+docker build -f Docker/DevelopmentSlim/Dockerfile \
+  -t "cratis/chronicle:$stamp-development-slim" .
+docker image inspect "cratis/chronicle:$stamp-development-slim"
+```
+
+Pass: build exits `0` and inspection shows the expected tag and architecture.
+Never push these images. Testcontainers uses a local image when the selected tag
+exists in its daemon; ensure the test process uses that same daemon.
+
+### 4. Use in the consumer
+
+```bash
+bash "$local" use-nuget "$consumer" "$stamp" Cratis.Chronicle
+# Source the absolute session/env path printed by use-nuget.
+# For npm instead: bash "$local" use-npm "$consumer" "$stamp"
+export CHRONICLE_KERNEL_VERSION="$stamp" # Studio integration specs, if used
+```
+
+Pass: the helper reports overridden IDs and restore resolves them to local
+artifacts. Follow any printed `--configfile` instruction. Run Yarn install after
+`use-npm`; it adds file-tarball resolutions, not links to source folders.
+
+### 5. Build and exercise the consumer
+
+From the consumer root, with the printed NuGet environment sourced:
+
+```bash
+dotnet build path/to/consumer.slnx -c Release -warnaserror
+dotnet test path/to/Integration.csproj -c Release --no-build --filter '<regression>'
+```
+
+Substitute the repository's actual commands; for frontend fixes run build, lint,
+specs and the previously broken UI action. Pass: the reproducing spec/action now
+succeeds, at least one intended filtered spec actually ran, and the consumer's
+required CI-equivalent gates pass. Zero matched tests is not proof. Studio local
+Debug builds skip analyzers: pass its full-build switch when matching CI. Read the recipe
+for that switch. On failure, change the producer and repeat with a distinct stamp;
+do not request a release to debug the next round.
+
+### 6. Check before commit or push
+
+```bash
+bash "$local" check "$consumer"
+bash "$local" check "$producer"
+```
+
+Pass: exit `0`, reported file count, `0 leaks`. The scan examines added/changed
+tracked lines against HEAD (or `--staged`) plus non-ignored untracked file contents.
+It detects stamped local versions, the configured feed path, NuGet overlay/source
+properties, package-version updates and local npm file/link/portal references.
+It does not inspect committed history, ignored files, active shell variables or
+all resolved dependencies. A clean diff can report zero files; it is not proof
+that the overlay was inactive. Inspect actual resolution and restore explicitly.
+
+### 7. Restore
+
+```bash
+bash "$local" restore "$consumer"
+unset DirectoryPackagesPropsPath RestoreAdditionalProjectSources CHRONICLE_KERNEL_VERSION
+bash "$local" check "$consumer"
+```
+
+Pass: restoration exits `0`, local overlay files are removed and `check` reports
+`0 leaks`. npm restore accepts overlay-only resolutions and local tarball lockfile
+entries after Yarn install; unrelated edits are refused with backups retained.
+Review conflicts and restore only overlay changes manually, then retry. Never
+overwrite unrelated work. Reinstall released npm dependencies
+and clear image/compose/Gradle selection too. Check the producer for codegen drift;
+Workbench builds can regenerate tracked proxies. Prefer a throwaway worktree, or
+use `git checkout -- <generated-path>` only after proving those edits are disposable
+build output, not pre-existing work.
+
+### 8. Clean
+
+```bash
+bash "$local" clean "$consumer" --stamp "$stamp"
+# Review listed subjects and stop task-owned containers first.
+bash "$local" clean "$consumer" --stamp "$stamp" --apply
+```
+
+Pass: expected subjects listed, then removed without force. Cleanup covers local
+feed packages, NuGet version folders, discoverable Yarn cache entries, local image
+tags and registered sessions; unresolved npm backups block it. Missing Docker/Yarn
+probes are reported as skipped cleanup, not proof those stores are empty. Default
+fuse: 500 subjects; investigate an unexpectedly large list instead of raising it.
+Prefer `--stamp` to `--all` on shared machines.
+
+## Configuration and results
+
+The trusted shell config `${XDG_CONFIG_HOME:-$HOME/.config}/cratis/local-packages.env`
+is sourced before defaults. Do not put credentials in it. Environment settings:
+
+| Setting | Default / purpose |
+| --- | --- |
+| `CRATIS_LOCAL_FEED` | `${XDG_CACHE_HOME:-$HOME/.cache}/cratis/local-feed`; outside tracked files |
+| `CRATIS_LOCAL_SESSION_DIR` | `<absolute-git-dir>/cratis-local`; per-worktree overlays/backups |
+| `NUGET_PACKAGES` | `$HOME/.nuget/packages`; shared cache, unique version folders |
+| `CRATIS_LOCAL_CLEAN_MAX` | `500`; cleanup subject fuse |
+| `CRATIS_LOCAL_RUN` | Optional executable wrapper receiving `build <label> -- <command...>` |
+
+If the environment has a build queue wrapper, set `CRATIS_LOCAL_RUN` to its absolute
+executable path. The helper wraps pack steps only; run other heavy builds, image
+builds and container specs through that environment's wrapper separately. No queue
+wrapper is required by the corpus. Global `--dry-run` prints mutations while still
+doing read-only discovery.
+
+Helper exit codes: `0` success, `1` findings/failed operation, `2` cannot run or
+invalid input. Neither `1` nor `2` is a pass. After script changes, execute
+`bash "$local" --self-test`; pass requires printed passed/skipped counts and exit
+`0`. npm overlay/restore tests run when node is on the inherited PATH; real packing
+is not exercised by this hermetic self-test. Report any unrun ecosystem checks.
+
+## Why the local loop
+
+A release chain runs producer PR, producer CI and publication, then a consumer
+pin bump and consumer CI, with hand-offs between each step. For a Chronicle fix
+consumed by Studio that is roughly 15–25 minutes of publishing, a bump pull
+request and another 20–30 minutes of consumer CI, and in practice hours of
+latency between them. A fix that turns out not to work repeats all of it.
+
+The local loop for the same chain, in run time: packing the client packages
+about 1–2 minutes, publishing the kernel a few minutes, building the image
+seconds with a warm layer cache, building the consumer's spec project about
+6 minutes, and an integration spec class seconds to minutes. Every iteration
+stays local. A shared build queue adds its own waiting time on top; that is
+machine load, not part of the loop.
+
+The loop also surfaces incompatibilities before anything ships: a consumer that
+does not yet supply what a newer kernel requires at startup fails here, in
+minutes, instead of after a release and a pin bump.
+
+## Conditional recipes
+
+- Read [references/dotnet-nuget.md](references/dotnet-nuget.md) when using NuGet, CPM, source mapping or IDE restore.
+- Read [references/npm-yarn.md](references/npm-yarn.md) when packing frontend libraries or restoring Yarn overlays.
+- Read [references/docker-images.md](references/docker-images.md) when publishing a kernel or selecting images in a consumer.
+- Read [references/go-jvm-python-elixir.md](references/go-jvm-python-elixir.md) when the boundary uses another language toolchain.
+- Read [references/worked-examples.md](references/worked-examples.md) when following Chronicle → Studio, Fundamentals → Arc or Components → Studio.
+- Read [references/other-environments.md](references/other-environments.md) when running on another developer machine or an agent host.
+
+Read `scripts/npm-restore-check.cjs` when inspecting the read-only npm restoration
+guard; `restore` executes it when npm files differ from the saved overlay state.

package/package/corpus/skills/cratis-engineering-local-cross-repo-verification/references/docker-images.md

@@ -0,0 +1,86 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Docker images
+
+## Chronicle kernel
+
+Use the producer's current Dockerfile as the source for build inputs. For
+`Docker/DevelopmentSlim/Dockerfile`, both published kernel output and Workbench
+assets must exist before `docker build`. From the Chronicle root:
+
+```bash
+# Native arm64 daemon; use linux-x64 and out/x64 for an amd64 daemon.
+dotnet publish Source/Kernel/Server/Server.csproj -c Release -r linux-arm64 \
+  -p:PublishReadyToRun=true -p:DefineConstants=DEVELOPMENT \
+  -o Source/Kernel/Server/out/arm64 \
+  "-p:Version=$stamp" "-p:PackageVersion=$stamp"
+cd Source/Workbench
+yarn install --immutable
+yarn build
+cd ../..
+docker build --platform linux/arm64 -f Docker/DevelopmentSlim/Dockerfile \
+  -t "cratis/chronicle:$stamp-development-slim" .
+docker image inspect "cratis/chronicle:$stamp-development-slim"
+```
+
+Run each heavy command through the host's queue wrapper when one exists. The
+Workbench build produces `Source/Workbench/wwwroot`; do not substitute an empty
+folder to get a green Docker build. Its build can regenerate tracked proxies.
+Check the diff immediately; use an isolated worktree or revert only known
+disposable generated drift before repeating. A broad checkout can destroy work.
+
+Keep the development publish flags aligned with the producer's CI: the
+`DEVELOPMENT` constant enables test reset APIs; ReadyToRun affects throughput.
+The Docker copy script selects `out/arm64` or `out/x64` according to the image
+architecture. Keep the publish RID, output folder and Docker platform aligned.
+The development-slim image has no embedded MongoDB: the test/compose network must
+supply it. `Docker/Development/Dockerfile` is the bundled-development alternative;
+build it with `-f Docker/Development/Dockerfile` and tag it
+`cratis/chronicle:$stamp-development`. Inspect its current inputs too; do not
+substitute that tag for a fixture requiring `-development-slim`. Debug vs Release builds can differ materially in throughput; keep
+Release for comparable kernel performance and state the actual architecture.
+
+## Consumer selection
+
+Studio integration specs select the local stamped kernel through:
+
+```bash
+export CHRONICLE_KERNEL_VERSION="$stamp"
+# Run Studio's actual regression spec and integration gates in this shell.
+```
+
+Its fixture selects `cratis/chronicle:<version>-development-slim`. Do not put the
+suffix in `CHRONICLE_KERNEL_VERSION` twice. Testcontainers can use the pre-existing
+tag without a registry push. Inspect its logs to confirm that tag was started;
+a custom pull policy may override local reuse. The image must be in the daemon
+the test process actually uses, not merely another Docker context.
+
+Chronicle Aspire hosting follows the package version for kernel image selection:
+consume the stamped Aspire package too, and ensure its selected image suffix
+exists locally. Inspect the generated resource/image configuration rather than
+assuming Studio's environment override applies to Aspire.
+
+Kotlin consumers with the kernel-image Gradle option can pass the full local tag:
+
+```bash
+./gradlew test "-PchronicleKernelImage=cratis/chronicle:$stamp-development-slim"
+```
+
+Confirm that the consumer build actually wires this property into its fixture;
+Gradle can accept unused project properties without selecting another image.
+
+Other consumers can use an untracked compose override with the stamped `image:`
+value, or their fixture's documented image option. Run `docker compose config`
+with the same compose files/options to inspect the resulting selection. Never
+commit a local tag or push the image as part of local proof.
+
+## Stop, restore, clean
+
+After proof, stop task-owned containers, unset `CHRONICLE_KERNEL_VERSION`, remove
+only task-owned compose overrides and run the helper's `restore` plus `check`.
+Review `clean --stamp "$stamp"` and then `clean --stamp "$stamp" --apply`.
+The helper lists matching tags and runs `docker rmi` without force; images still
+in use can fail removal. Resolve the owning container instead of adding `-f`.
+A Docker probe unavailable or over its deadline is a reported skip, not evidence
+that no local tags remain. Do not replace this with global Docker pruning.

package/package/corpus/skills/cratis-engineering-local-cross-repo-verification/references/dotnet-nuget.md

@@ -0,0 +1,87 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# .NET and NuGet
+
+## CPM overlay
+
+Execute the helper from the entry point. `pack-nuget PRODUCER STAMP TARGET...`
+passes `PackageVersion` and `Version` to Release `dotnet pack`. Use the entire
+changed dependency closure, not just the top-level package. Unchanged dependencies
+may remain released; inspect the resulting nuspec and restore graph to distinguish
+them from an accidental published fallback.
+
+`use-nuget CONSUMER STAMP [ID...]` requires a root `Directory.Packages.props`.
+Without IDs it selects every package with `<id>.<stamp>.nupkg` in the feed,
+including transitive dependencies absent from the consumer props. The generated
+overlay imports the consumer's real props, uses `PackageVersion Update` for IDs
+already pinned there and `PackageVersion Include` for the others, and enables
+`CentralPackageTransitivePinningEnabled` so the added IDs pin transitive packages.
+An `Update` alone cannot add an absent ID. It does not copy or edit the props in git.
+
+```bash
+bash "$local" use-nuget "$consumer" "$stamp" Cratis.Chronicle Cratis.Chronicle.CodeAnalysis
+# Source the absolute env path printed by the command.
+source /absolute/session/path/env
+cd "$consumer"
+dotnet restore path/to/consumer.slnx
+dotnet build path/to/consumer.slnx -c Release --no-restore -warnaserror
+```
+
+The printed properties are `DirectoryPackagesPropsPath` and
+`RestoreAdditionalProjectSources`. For an IDE, launch it from that shell, or pass
+the printed `-p:` properties explicitly to its build. Verify restore uses the
+stamp in `obj/project.assets.json`; shell environment changes do not reconfigure
+an already-running IDE. A config overlay printed below must also reach IDE restore.
+
+The `CRATIS_LOCAL_RUN` adapter applies to pack steps, not these restore/build
+commands; route each heavy command separately through the host's build queue.
+
+## Source mapping
+
+If a tracked root NuGet config has `packageSourceMapping`, the helper prints an
+additional restore command with `--configfile <session>/nuget.config`. Use it.
+The generated config preserves existing entries, makes relative sources absolute,
+adds a `cratis-local` source, removes exact selected-ID mappings from remote
+sources, and maps those IDs exactly to the local source. Exact local matches take
+precedence over wildcard patterns. Inspect the generated config and restore output
+for nested/imported/unsupported configuration; do not assume this is a general
+NuGet XML rewriter. An incomplete mapping or existing `cratis-local` key is refused.
+
+## Versions and cache
+
+Generate a fresh stamp with the helper, not `0.0.0-local`. The next-patch prerelease
+must sort above the versions required transitively or NuGet may report NU1605.
+A stale highest tag or dependency with a newer minimum needs investigation, not a
+warning suppression. The suffix is `-local.<12-digit-UTC-minute>.g<sha7>`; the `g` prefix makes an
+all-digit SHA unambiguously nonnumeric in SemVer. Dirty edits are not encoded.
+Wait for a distinct UTC minute or commit before repacking changed contents.
+
+The existing global cache is shared safely only because local versions have
+unique directories. Do not repack changed bits under the same version. Use
+`clean --stamp "$stamp"` to list that stamp's version folders, then `--apply`
+after review; do not delete the entire NuGet cache.
+
+## Non-CPM escape
+
+The helper refuses a consumer without root CPM props. Use an untracked isolated
+project/worktree copy with explicit `PackageReference` versions and restore with
+`--source "$CRATIS_LOCAL_FEED/nuget"` plus the normal remote sources. Supply every
+needed source because `--source` replaces configured sources. Inspect the resolved
+graph. Never edit versions intended to ship merely to make local proof work.
+
+## Restoration and drift
+
+`restore` removes session props, generated config and env files, then runs `check`.
+It cannot unset variables in the calling shell:
+
+```bash
+bash "$local" restore "$consumer"
+unset DirectoryPackagesPropsPath RestoreAdditionalProjectSources
+bash "$local" check "$consumer"
+```
+
+Inspect producer and consumer diffs. Workbench builds in particular can regenerate
+tracked proxies. Prefer a throwaway worktree; revert only known disposable output
+with `git checkout -- <generated-path>` after checking it was clean beforehand.
+No blanket checkout/reset is part of this workflow.

package/package/corpus/skills/cratis-engineering-local-cross-repo-verification/references/go-jvm-python-elixir.md

@@ -0,0 +1,83 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Other language boundaries
+
+These are manual equivalents, not additional helper subcommands. Discover the
+producer/consumer build conventions first. Keep local configuration outside
+tracked files, preserve edits, run consumer regression specs, remove substitutions
+and inspect the diff before commit/push. The helper's leak check does not recognize
+all Go, Gradle, Python or Mix substitutions; manual inspection is required too.
+
+## Go modules
+
+Prefer an untracked workspace for a source-level reproduction:
+
+```bash
+# In an ignored scratch directory, using absolute producer/consumer module paths:
+go work init /absolute/consumer/module /absolute/producer/module
+export GOWORK="$PWD/go.work"
+cd /absolute/consumer/module
+go test ./...
+```
+
+The producer's module path must match the dependency; add the actual module roots
+in a multi-module repository. Alternatively use `go mod edit
+-replace=example.org/producer=/absolute/producer/module` in a disposable consumer
+copy. `replace` changes go.mod, so never commit it; preserve the original file and
+remove only that override afterward. Workspace/replace testing does not prove a
+published module archive's contents. If packaging is part of the bug, also inspect
+and test the release module layout. Unset `GOWORK` and inspect go.mod/go.sum and
+workspace files after proof; a scratch workspace must not be committed.
+
+## Kotlin / JVM
+
+For compatible Gradle builds, use composite substitution:
+
+```bash
+cd /absolute/consumer
+./gradlew --include-build /absolute/producer test
+```
+
+Gradle substitutes matching project coordinates; inspect `dependencies` or
+`dependencyInsight` to confirm the intended module, rather than trusting a green
+task that still used a released artifact. Where composites do not match the
+published layout, publish the producer's configured publications with
+`./gradlew publishToMavenLocal` using `$stamp` as the configured publication
+version, then select that version through an untracked consumer init
+script/repository override. Configure
+`mavenLocal()` only in that override and confirm effective coordinates. Do not
+assume every build accepts a generic version property. Remove only that local
+version's artifacts after review, not the whole Maven cache. Remove overrides and
+inspect settings/build scripts and lockfiles before commit/push.
+
+## Python
+
+Prefer the actual wheel for package-boundary proof, in a disposable virtualenv:
+
+```bash
+# Requires the repository's existing build frontend; do not install tools blindly.
+python -m build --wheel --outdir /absolute/scratch/wheels /absolute/producer
+python -m venv /absolute/scratch/venv
+/absolute/scratch/venv/bin/python -m pip install /absolute/scratch/wheels/<wheel>.whl
+# Install the consumer's remaining dependencies and execute its regression tests
+# with that interpreter, confirming it did not replace the selected wheel.
+```
+
+If the consumer needs an editable install, use that environment's `pip install -e
+/absolute/producer` and state that this proves source integration, not wheel
+contents. Inspect installed versions and module paths; reusing a global Python
+can silently exercise another copy. Never record absolute wheel/editable paths in
+shipped requirements or lockfiles. Remove the task-owned virtualenv/wheels after
+review and inspect the consumer diff.
+
+## Elixir
+
+In an isolated consumer copy, temporarily replace the relevant Mix dependency
+with its exact project name and `path: "/absolute/producer"`; use `override: true`
+only where transitive resolution requires that substitution. Run `mix deps.get`
+and the consumer's regression `mix test` tasks. Inspect `mix deps` for the selected
+path. This tests local source, not the contents of a Hex release. Restore only the
+local dependency edit and corresponding lockfile change; re-fetch released deps
+before final gates. Inspect mix.exs/mix.lock and remove task-owned build/cache
+outputs without deleting unrelated work.