fix: remove tensor patch product leakage

Author: nshkrdotcom

CHANGELOG.md

@@ -8,4 +8,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.0] - 2026-05-23
 
 ### Added
-- Initial release of `CrucibleTensorPatch` under the TRINITY decomposition.
+- Initial release of `CrucibleTensorPatch` from the monolith extraction.

MIGRATION.md

@@ -1,8 +1,7 @@
 # Migration Notes
 
-This repo was scaffolded during TRINITY decomposition Phase 1 so
-`trinity_framework` could resolve local path dependencies before the public
-GitHub repos existed.
+This repo was scaffolded during the monolith extraction so framework consumers
+could resolve local path dependencies before the public GitHub repos existed.
 
 Source material for the Phase 4 implementation:
 

README.md

@@ -20,6 +20,22 @@ identity and SVF patch operations, manifest/checksum emission, resume/force
 rules, backend label round trips, and stage comparison. It intentionally avoids
 provider, tracing, and orchestration dependencies.
 
+## What It Provides
+
+- `CrucibleTensorPatch.Plan` loads and validates patch plans from maps or JSON
+  files.
+- `CrucibleTensorPatch.Apply` applies identity and SVF patch operations and
+  writes deterministic safetensors outputs.
+- `CrucibleTensorPatch.ParamTree` patches nested parameter trees using manifest
+  selected-tensor entries.
+- `CrucibleTensorPatch.Manifest` emits deterministic operation manifests.
+- `CrucibleTensorPatch.BackendLabel` round-trips known Nx/EXLA backend labels.
+- `CrucibleTensorPatch.StageCheck` compares stage reports using shared tensor
+  comparison behavior.
+
+The package does not fetch models, load provider credentials, run coordination
+loops, or own application runtime configuration.
+
 ## Installation
 
 If [available in Hex](https://hex.pm/docs/publish), the package can be installed
@@ -37,6 +53,112 @@ Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_do
 and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
 be found at <https://hexdocs.pm/crucible_tensor_patch>.
 
+## Plan Schema
+
+A plan contains a `schema` string and an ordered `operations` list:
+
+```elixir
+plan_doc = %{
+  "schema" => "example.v1",
+  "operations" => [
+    %{
+      "id" => "copy_layer",
+      "operation" => "identity",
+      "source_path" => "layers.0.kernel",
+      "output_path" => "layers/0000_kernel.safetensors",
+      "expected_shape" => [2, 2],
+      "expected_dtype" => "f32"
+    }
+  ]
+}
+
+{:ok, plan} = CrucibleTensorPatch.Plan.load(plan_doc)
+```
+
+Supported operations are:
+
+- `"identity"`: copies a source tensor to a safetensors output.
+- `"svf_apply"`: reconstructs a tensor from SVD/SVF components and scale
+  offsets before writing the output.
+
+Supported dtype strings are `bf16`, `f16`, `f32`, `i32`, and `i64`.
+
+## Applying Identity Operations
+
+```elixir
+source = %{
+  "layers.0.kernel" => Nx.tensor([[1.0, 2.0], [3.0, 4.0]], type: :f32)
+}
+
+{:ok, manifest} =
+  CrucibleTensorPatch.Apply.apply(
+    plan,
+    source,
+    "out/patch",
+    force: false
+  )
+```
+
+The result manifest includes operation status, output paths, skip state, and
+SHA-256 checksums. `manifest.json` is written by default.
+
+## Applying SVF Operations
+
+SVF operations reference component tensors by name:
+
+```elixir
+operation = %{
+  "id" => "svf_layer",
+  "operation" => "svf_apply",
+  "source_path" => "layers.0.kernel",
+  "output_path" => "layers/0000_kernel.safetensors",
+  "inputs" => %{
+    "u" => "layer_0_u",
+    "s" => "layer_0_s",
+    "v" => "layer_0_v",
+    "scale_offsets" => "layer_0_offsets"
+  },
+  "expected_shape" => [2, 2],
+  "expected_dtype" => "f32"
+}
+```
+
+Pass the component tensors through the `:components` option:
+
+```elixir
+CrucibleTensorPatch.Apply.apply(plan, source, "out/patch",
+  components: %{
+    "layer_0_u" => u,
+    "layer_0_s" => s,
+    "layer_0_v" => v,
+    "layer_0_offsets" => offsets
+  }
+)
+```
+
+## Patching Parameter Trees
+
+```elixir
+patched =
+  CrucibleTensorPatch.Apply.patch_params!(
+    params,
+    manifest,
+    tensors,
+    cast_tensors: true
+  )
+```
+
+The patcher accepts maps or structs with a `:data` field. Manifest entries may
+include explicit `segments`; otherwise the path string is split into traversal
+segments.
+
+## Resume And Force
+
+When an operation has `expected_output_sha256` and the output file already
+exists, the applier verifies the checksum and skips completed output. A checksum
+mismatch raises. Pass `force: true` to rewrite outputs regardless of existing
+files.
+
 ## CI
 
 ```sh
@@ -46,6 +168,10 @@ mix ci
 Large local fixture checks are opt-in:
 
 ```sh
-TRINITY_ARTIFACT_DIR=~/p/g/n/trinity_coordinator/priv/sakana_trinity/adapted_qwen3_0_6b_layer26 \
-  mix test --only large_tensor_patch
+mkdir -p tmp
+ln -s /path/to/artifact_bundle tmp/crucible_tensor_patch_fixture
+mix test --only large_tensor_patch
 ```
+
+`mix ci` runs dependency fetch, format check, warning-as-error compile, tests,
+Credo strict, Dialyzer, and docs generation.

lib/crucible_tensor_patch.ex

@@ -1,18 +1,5 @@
 defmodule CrucibleTensorPatch do
   @moduledoc """
-  Documentation for `CrucibleTensorPatch`.
+  Deterministic tensor patch plans and patch application for model surgery.
   """
-
-  @doc """
-  Hello world.
-
-  ## Examples
-
-      iex> CrucibleTensorPatch.hello()
-      :world
-
-  """
-  def hello do
-    :world
-  end
 end

lib/crucible_tensor_patch/apply.ex

@@ -5,6 +5,13 @@ defmodule CrucibleTensorPatch.Apply do
   alias CrucibleSafetensors.{Checksum, Writer}
   alias CrucibleTensorPatch.{Errors, Manifest, Operation, ParamTree, Plan, TensorPath}
 
+  @input_atom_keys %{
+    "scale_offsets" => :scale_offsets,
+    "s" => :s,
+    "u" => :u,
+    "v" => :v
+  }
+
   @doc "Applies a plan to source tensors and writes output safetensors."
   @spec apply(Plan.t(), map(), Path.t(), keyword()) :: {:ok, map()} | {:error, Exception.t()}
   def apply(%Plan{} = plan, source_artifact, out_dir, opts \\ []) when is_map(source_artifact) do
@@ -116,7 +123,7 @@ defmodule CrucibleTensorPatch.Apply do
   end
 
   defp fetch_input!(inputs, components, name) do
-    value = Map.get(inputs, name) || Map.get(inputs, String.to_atom(name))
+    value = input_value(inputs, name)
 
     cond do
       match?(%Nx.Tensor{}, value) -> value
@@ -125,6 +132,19 @@ defmodule CrucibleTensorPatch.Apply do
     end
   end
 
+  defp input_value(inputs, name) do
+    case Map.fetch(inputs, name) do
+      {:ok, value} ->
+        value
+
+      :error ->
+        case Map.fetch(@input_atom_keys, name) do
+          {:ok, atom_key} -> Map.get(inputs, atom_key)
+          :error -> nil
+        end
+    end
+  end
+
   defp validate_tensor!(operation, %Nx.Tensor{} = tensor) do
     expected_shape = normalize_shape(operation.expected_shape)
 

lib/crucible_tensor_patch/plan.ex

@@ -5,6 +5,13 @@ defmodule CrucibleTensorPatch.Plan do
 
   @operations [:identity, :svf_apply]
   @operation_strings %{"identity" => :identity, "svf_apply" => :svf_apply}
+  @dtype_strings %{
+    "bf16" => :bf16,
+    "f16" => :f16,
+    "f32" => :f32,
+    "i32" => :i32,
+    "i64" => :i64
+  }
   @field_atom_keys %{
     "checksum_policy" => :checksum_policy,
     "expected_dtype" => :expected_dtype,
@@ -98,8 +105,14 @@ defmodule CrucibleTensorPatch.Plan do
   defp normalize_dtype(nil), do: nil
   defp normalize_dtype(dtype) when is_atom(dtype), do: dtype
 
-  defp normalize_dtype(dtype) when is_binary(dtype),
-    do: dtype |> String.downcase() |> String.to_existing_atom()
+  defp normalize_dtype(dtype) when is_binary(dtype) do
+    normalized = String.downcase(dtype)
+
+    case Map.fetch(@dtype_strings, normalized) do
+      {:ok, atom} -> atom
+      :error -> raise Errors, "unsupported dtype #{inspect(dtype)}"
+    end
+  end
 
   defp normalize_checksum(nil), do: nil
   defp normalize_checksum(policy) when is_atom(policy), do: policy

test/crucible_tensor_patch/large_tensor_patch_test.exs

@@ -5,11 +5,7 @@ defmodule CrucibleTensorPatch.LargeTensorPatchTest do
 
   @tag :large_tensor_patch
   test "fixture artifact manifest can seed a patch plan" do
-    artifact_dir =
-      System.get_env(
-        "TRINITY_ARTIFACT_DIR",
-        Path.expand("~/p/g/n/trinity_coordinator/priv/sakana_trinity/adapted_qwen3_0_6b_layer26")
-      )
+    artifact_dir = Path.expand("tmp/crucible_tensor_patch_fixture")
 
     manifest_path = Path.join(artifact_dir, "manifest.json")
     assert File.regular?(manifest_path)

test/crucible_tensor_patch/plan_apply_test.exs

@@ -24,6 +24,19 @@ defmodule CrucibleTensorPatch.PlanApplyTest do
     assert operation.expected_dtype == :f32
   end
 
+  test "Plan.load/1 normalizes supported dtype strings without dynamic atoms" do
+    assert {:ok, plan} =
+             Plan.load(%{
+               "operations" => [
+                 identity_op("copy", "layer.kernel", "copy.safetensors")
+                 |> Map.put("expected_dtype", "BF16")
+               ]
+             })
+
+    assert [operation] = plan.operations
+    assert operation.expected_dtype == :bf16
+  end
+
   test "Plan.load/1 rejects unknown operations" do
     assert {:error, %Errors{message: message}} =
              Plan.load(%{
@@ -85,6 +98,43 @@ defmodule CrucibleTensorPatch.PlanApplyTest do
     assert [%{"status" => "complete"}] = manifest["operations"]
   end
 
+  test "Apply.apply/4 accepts fixed atom input keys" do
+    dir = tmp_dir()
+    source = %{"layer.kernel" => Nx.tensor([[2.0, 4.0], [1.0, 2.0]], type: :f32)}
+
+    decomp =
+      CrucibleFactorization.SVD.decompose_tensor(source["layer.kernel"], compute_type: :f32)
+
+    offsets = Nx.broadcast(0.0, {Nx.axis_size(decomp.s, 0)})
+
+    {:ok, plan} =
+      Plan.load(%{
+        "operations" => [
+          %{
+            "id" => "svf",
+            "operation" => "svf_apply",
+            "source_path" => "layer.kernel",
+            "output_path" => "svf.safetensors",
+            "inputs" => %{u: "u", s: "s", v: "v", scale_offsets: "offsets"},
+            "expected_shape" => [2, 2],
+            "expected_dtype" => "f32"
+          }
+        ]
+      })
+
+    assert {:ok, manifest} =
+             Apply.apply(plan, source, dir,
+               components: %{
+                 "u" => decomp.u,
+                 "s" => decomp.s,
+                 "v" => decomp.v,
+                 "offsets" => offsets
+               }
+             )
+
+    assert [%{"status" => "complete"}] = manifest["operations"]
+  end
+
   test "Apply.apply/4 supports resume and force" do
     dir = tmp_dir()
     source = %{"layer.kernel" => Nx.tensor([[1.0, 2.0]], type: :f32)}