defp store(owner, message, context_consent, %{"category" => category, "claim" => claim})

       when is_binary(category) and is_binary(claim) do

    category = MemoryContract.normalize_category(category)

    consent = consent_evidence(message, claim, context_consent)

    case ProfileMemory.remember_explicit(owner, %{

           category: category,

           claim: claim,

           creator: "user_explicit",

           provenance: %{

             "consent_kind" => consent.kind,

             "operation" => "remember",

             "source_ref" => "message:#{message.id}"

           },

           sources: [

             %{

               source_ref: "message:#{message.id}",

               kind:

                 if(consent.kind in ["current_message", "conversation_context"],

                   do: "owner_statement",

                   else: "owner_confirmation"

                 )

             }

           ]

         }) do

      {:ok, remembered} ->

        {:ok, Map.put(remembered, :category, category)}

      {:error, reason} when is_atom(reason) ->

    case consent_evidence(message, claim, context_consent) do

      {:ok, consent} ->

        case ProfileMemory.remember_explicit(owner, %{

               category: category,

               claim: claim,

               creator: "user_explicit",

               provenance: %{

                 "consent_kind" => consent.kind,

                 "operation" => "remember",

                 "source_ref" => "message:#{message.id}"

               },

               sources: [

                 %{

                   source_ref: "message:#{message.id}",

                   kind:

                     if(consent.kind == "current_message",

                       do: "owner_statement",

                       else: "owner_confirmation"

                     )

                 }

               ]

             }) do

          {:ok, remembered} ->

            {:ok, Map.put(remembered, :category, category)}

          {:error, reason} when is_atom(reason) ->

            {:error, category, reason}

          {:error, _bounded_reason} ->

            {:error, category, :memory_policy_refused}

        end

      {:error, reason} ->

        {:error, category, reason}

      {:error, _bounded_reason} ->

        {:error, category, :memory_policy_refused}

    end

  end

  end

  defp consent_evidence(message, claim, context_consent) do

    case Consent.remember(message.content, claim, context_consent) do

      {:ok, consent} -> consent

      {:error, _no_explicit_request} -> %{kind: "conversation_context"}

    end

    Consent.remember(message.content, claim, context_consent)

  end

  defp input_schema do

    assert {:ok, []} = ProfileMemory.list_current(scope.owner)

  end

  test "remember is durable and idempotent for explicit and plain statements", %{

  test "remember is durable and idempotent for explicit statements", %{

    snapshot: snapshot

  } do

    scope = browser("memory-explicit")

    assert {:ok, repeated} = Runner.run(snapshot, %{request | call_id: "call-repeat"}, context)

    assert repeated["result"]["receipt"]["disposition"] == "already_active"

    plain = user_message(scope.conversation, "I like detailed answers.")

    plain = user_message(scope.conversation, "Remember that I like detailed answers.")

    assert {:ok, automatic} =

             Runner.run(

    assert {:ok, [_first, _second]} = ProfileMemory.list_current(scope.owner)

  end

  test "a single call stores several facts across categories with one receipt", %{

  test "a single call with multiple unauthorized claims is refused", %{

    snapshot: snapshot

  } do

    scope = browser("memory-batch")

    message = user_message(scope.conversation, "I'm Chris, I run OpenAgents, and I like Elixir.")

    assert {:ok, batch} =

    assert {:ok, refused} =

             Runner.run(

               snapshot,

               call("memory_remember", %{

               context(scope, message)

             )

    assert batch["status"] == "succeeded"

    assert batch["result"]["receipt"]["disposition"] == "stored"

    assert length(batch["result"]["receipt"]["record_refs"]) == 3

    assert Enum.map(batch["result"]["results"], & &1["disposition"]) ==

             ["stored", "stored", "stored"]

    assert {:ok, records} = ProfileMemory.list_current(scope.owner)

    assert Enum.sort(Enum.map(records, & &1.category)) == ["name", "preference", "role"]

    assert refused["status"] == "refused"

    assert refused["error"]["code"] == "memory_consent_required"

    assert {:ok, []} = ProfileMemory.list_current(scope.owner)

  end

  test "an unrecognized category is coerced to other instead of refusing the batch", %{

  test "an unrecognized category is coerced to other when the claim is explicitly authorized", %{

    snapshot: snapshot

  } do

    scope = browser("memory-coerced-category")

    message = user_message(scope.conversation, "I use a split keyboard and live in Austin.")

    message = user_message(scope.conversation, "Remember that I use a split keyboard.")

    assert {:ok, stored} =

             Runner.run(

               snapshot,

               call("memory_remember", %{

                 "memories" => [

                   %{"category" => "Equipment", "claim" => "Uses a split keyboard"},

                   %{"category" => "location", "claim" => "Lives in Austin"}

                   %{"category" => "Equipment", "claim" => "I use a split keyboard"}

                 ]

               }),

               context(scope, message)

             )

    assert stored["status"] == "succeeded"

    assert Enum.map(stored["result"]["results"], & &1["disposition"]) == ["stored", "stored"]

    assert Enum.map(stored["result"]["results"], & &1["category"]) == ["other", "other"]

    assert {:ok, records} = ProfileMemory.list_current(scope.owner)

    assert Enum.all?(records, &(&1.category == "other"))

    assert [entry] = stored["result"]["results"]

    assert entry["disposition"] == "stored"

    assert entry["category"] == "other"

    assert {:ok, [record]} = ProfileMemory.list_current(scope.owner)

    assert record.category == "other"

  end

  test "automatic storage keeps the current message as its owner-scoped source", %{

  test "a paraphrased claim without exact current or host consent is refused", %{

    snapshot: snapshot

  } do

    scope = browser("memory-automatic")

    statement = user_message(scope.conversation, "I'm mostly working on the One repo lately.")

    assert {:ok, stored} =

    assert {:ok, refused} =

             Runner.run(

               snapshot,

               call("memory_remember", %{

               context(scope, statement)

             )

    assert stored["status"] == "succeeded"

    assert [entry] = stored["result"]["results"]

    assert entry["memory"]["source_refs"] == ["message:#{statement.id}"]

    assert {:ok, [record]} = ProfileMemory.list_current(scope.owner)

    assert record.provenance["consent_kind"] == "conversation_context"

    assert refused["status"] == "refused"

    assert refused["error"]["code"] == "memory_consent_required"

    assert {:ok, []} = ProfileMemory.list_current(scope.owner)

  end

  test "a host-recorded confirmation covers its candidate and other claims store automatically",

  test "a host-recorded confirmation covers its candidate and refuses a mismatch",

       %{

         snapshot: snapshot

       } do

      )

    )

    assert {:ok, fallback} =

    assert {:ok, refused} =

             Runner.run(

               snapshot,

               call("memory_remember", %{

               confirmed_context

             )

    assert fallback["status"] == "succeeded"

    assert refused["status"] == "refused"

    assert refused["error"]["code"] == "memory_consent_mismatch"

    assert {:ok, records} = ProfileMemory.list_current(scope.owner)

    record = Enum.find(records, &(&1.claim == "I prefer detailed answers"))

    assert record.provenance["consent_kind"] == "conversation_context"

    refute Enum.any?(records, &(&1.claim == "I prefer detailed answers"))

  end

  test "a fabricated claim with no consent record authorizing it is refused", %{

    snapshot: snapshot

  } do

    scope = browser("memory-fabricated")

    message = user_message(scope.conversation, "Discussing project plans.")

    assert {:ok, refused} =

             Runner.run(

               snapshot,

               call("memory_remember", %{

                 "memories" => [

                   %{"category" => "preference", "claim" => "I prefer detailed answers"}

                 ]

               }),

               context(scope, message)

             )

    assert refused["status"] == "refused"

    assert refused["error"]["code"] == "memory_consent_required"

    assert {:ok, []} = ProfileMemory.list_current(scope.owner)

  end

  test "correct supersedes a conflicting record with the new claim", %{snapshot: snapshot} do