chore: prepare Unity and Godot store packages

.github/workflows/ci.yml

@@ -64,6 +64,9 @@ jobs:
           DOTNET_INSTALL_DIR: ${{ runner.temp }}/.dotnet
         with:
           global-json-file: global.json
+      - name: Verify store listings and media
+        shell: pwsh
+        run: ./tools/Test-StoreListings.ps1
       - name: Build Unity compile stubs
         shell: pwsh
         run: dotnet build tests/OpenGameAgent.Unity.Stubs/OpenGameAgent.Unity.Stubs.csproj -c Release -o artifacts/unity-stubs

docs/store-listings/README.md

@@ -0,0 +1,15 @@
+# Store listing source
+
+This directory is the canonical source for the Godot Asset Store and Unity Asset Store listings. Keep the public forms synchronized with these files.
+
+- `godot.md`: Godot listing copy and review disclosures.
+- `unity.md`: Unity listing copy and review disclosures.
+- `artwork/`: editable 16:9 SVG source and rendered upload assets.
+
+Regenerate PNG upload assets with:
+
+```powershell
+./tools/Render-StoreArtwork.ps1 -Godot godot.exe
+```
+
+The packages are free, open-source engine adapters. They include the runtime/client surface and a deterministic no-key sample. Real model calls require a separately configured provider or an OpenGameAgent server; no provider account, API key, or paid service is bundled.

docs/store-listings/godot.md

@@ -0,0 +1,57 @@
+# Godot Asset Store listing
+
+## Identity
+
+- Publisher: **OpenGameAgent**
+- Asset name: **OpenGameAgent**
+- Slug: `opengameagent`
+- Price: **Free**
+- License: **MIT**
+- Category: **Tools / AI**
+- Minimum engine: **Godot 4.7 .NET**
+- Source: <https://github.com/EricSun0218/OpenGameAgent>
+- Website: <https://opengameagent.com>
+
+## Summary
+
+Provider-neutral agent runtime for AI-native Godot games. Give NPCs structured world context, tool use, streaming responses, steering, and independent concurrent lives.
+
+## Description
+
+OpenGameAgent is an open-source runtime for building AI-native game characters and systems. It turns structured game state into an agent loop that can reason, call typed game tools, stream results, and continue across game time—without moving game authority into the model.
+
+The Godot 4.7 .NET add-on provides an `OpenGameAgentNode` that runs either in process or against an OpenGameAgent server. It exposes typed C# methods plus bounded, main-thread Godot signals for GDScript and UI integration.
+
+### Included
+
+- Structured `GameInput` with arbitrary JSON context and game-time moments
+- Stateful agent/tool loop with streaming lifecycle events
+- Local in-process and remote server modes
+- Actor-scoped steering, abort, cancellation, and bounded callback delivery
+- Multi-NPC concurrency through isolated actor lanes
+- Shared runtime/client assemblies
+- Deterministic no-key example
+- MIT license and source code
+
+### Game authority
+
+Models propose typed intents. Your game still validates rules, resources, revisions, permissions, physics, pathfinding, and final state changes. Optional OpenGameAgent packages add durable actions, memory, scheduling, workflows, media providers, MCP, and other capabilities.
+
+### Providers and privacy
+
+No model or paid service is bundled. OpenGameAgent itself does not collect or transmit project data. Data leaves the game only through providers or services explicitly configured by the developer. Do not embed a permanent provider key in an exported client; use BYOK, a local endpoint, short-lived credentials, or a server.
+
+### Installation
+
+Copy `addons/open_game_agent` into a Godot 4.7 .NET project, import `OpenGameAgent.Godot.props` from the project `.csproj`, and add `OpenGameAgentNode` to a scene or Autoload. Full instructions are included and maintained online.
+
+## Search tags
+
+`AI`, `agent`, `NPC`, `LLM`, `tools`, `memory`, `multi-agent`, `simulation`, `runtime`, `Godot C#`
+
+## Review notes
+
+- The add-on is a Godot 4.7 .NET runtime library; the GDScript editor plug-in is intentionally side-effect free.
+- The bundled sample is deterministic and makes no network request.
+- External provider packages, accounts, API terms, costs, and data policies are not included.
+- Package path is `addons/open_game_agent` and the license is present inside that directory.

docs/store-listings/unity.md

@@ -0,0 +1,58 @@
+# Unity Asset Store listing
+
+## Identity
+
+- Publisher: **OpenGameAgent**
+- Product: **OpenGameAgent — Agent Runtime for AI-Native Games**
+- Technical package: `com.opengameagent.runtime`
+- Price: **Free**
+- License: **MIT** (open-source SDK/tool; review under the applicable Unity package terms)
+- Category: **Tools / AI**
+- Minimum editor: **Unity 6 (6000.0.0f1)**
+- Tested editor: **Unity 6000.5.6f1 on Windows**
+- Source: <https://github.com/EricSun0218/OpenGameAgent>
+- Website: <https://opengameagent.com>
+
+## Short description
+
+Provider-neutral agent runtime for AI-native Unity games: structured context, typed tools, streaming, steering, local/server execution, and multi-NPC concurrency.
+
+## Description
+
+OpenGameAgent is an open-source runtime for building AI-native game characters and systems. Each NPC can receive structured world state, reason through an agent loop, call typed game tools, stream its response, and keep an independent life across game time.
+
+The Unity package provides `OpenGameAgentBehaviour` plus shared runtime/client assemblies. Run agents in the Unity process for a simple local architecture, or connect to an OpenGameAgent service when credentials, server authority, or scale belong outside the player.
+
+### Included
+
+- Structured JSON game context and explicit game-time moments
+- Stateful agent/tool loop with streamed lifecycle events
+- Local in-process and remote server modes
+- Actor-scoped steering, abort, cancellation, and bounded main-thread callbacks
+- Multi-NPC concurrency through isolated actor lanes
+- Deterministic no-key sample importable from Package Manager
+- Complete MIT and third-party notices
+
+### Designed for authoritative games
+
+Models propose typed intents. Your game validates rules, resources, revisions, permissions, physics, pathfinding, and final state changes. Optional OpenGameAgent packages add durable actions, memory, scheduling, workflows, media providers, MCP, and other capabilities.
+
+### Providers, keys, and privacy
+
+No model, provider account, API key, or paid service is bundled. OpenGameAgent itself does not collect or transmit project data. Data leaves the game only through providers or services explicitly configured by the developer. A permanent key embedded in a player can be extracted; use BYOK, a local endpoint, developer-issued short-lived credentials, or a server.
+
+### Getting started
+
+Install the UPM package, import **Minimal Local Agent** from the Samples tab, add `OpenGameAgentQuickstart` to a GameObject, and enter Play Mode. Then replace the deterministic sample provider with the provider or server configuration your game uses.
+
+## Search tags
+
+`AI`, `agent`, `NPC`, `LLM`, `tools`, `memory`, `multi-agent`, `simulation`, `runtime`, `Unity`
+
+## Dependencies and review disclosures
+
+- Bundles OpenGameAgent runtime/client assemblies and .NET support assemblies listed in `Third-Party Notices.txt`.
+- No external service is required for the included sample.
+- Real model use requires a separately configured provider or OpenGameAgent server and may have separate terms or charges.
+- The package never asks for or stores a provider key. Credential handling is chosen by the developer; permanent keys must not be shipped in player builds.
+- Package code does not use project/customer data to train any model.

engines/godot/addons/open_game_agent/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eric Sun and OpenGameAgent 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.

engines/godot/addons/open_game_agent/README.md

@@ -7,10 +7,16 @@ Godot 4.7 .NET adapter for the OpenGameAgent runtime.
 3. Add `OpenGameAgentNode` to a scene or Autoload.
 4. Call `Configure(runtime)` for in-process execution or `ConfigureRemote(client)` for a .NET service.
 
+For a no-key first run, copy `examples/minimal_local_agent/MinimalLocalAgent.cs` into your own scene script or instantiate its node from C#. It uses a deterministic provider and performs no network request.
+
 Use the typed async methods from C#. `SteerActorAsync` and `AbortActorAsync` work in local and remote modes. For GDScript, call `RunJson` and connect to `run_event`, `run_completed`, and `run_failed`. Stream signals use a bounded queue drained on the Godot thread; optional `Configure` arguments tune active runs, queue capacity, and per-frame budget. Admitted runs reserve terminal delivery.
 
 The distributable add-on contains its shared runtime DLLs. Generated packages belong in `engines/godot/artifacts` and are not committed.
 
 Persistence, provider, official extension, model-catalog, and external-tool packages are versioned separately so a project can include only what it needs. A permanent model key embedded in an exported game can be extracted; use BYOK, a local endpoint, or developer-issued short-lived credentials.
 
+OpenGameAgent itself does not collect or transmit project data. Data leaves the game only through providers or services explicitly configured by the developer. Provider accounts, API terms, usage charges, and data handling are controlled by those third parties.
+
+This add-on is open source under the MIT License. See `LICENSE` in this directory.
+
 Full setup, lifecycle, cancellation, and main-thread guidance is in `docs/engine-integration.md` at the repository root.

engines/godot/addons/open_game_agent/examples/minimal_local_agent/MinimalLocalAgent.cs

@@ -0,0 +1,46 @@
+#nullable enable
+
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Godot;
+using OpenGameAgent.Kernel;
+
+namespace OpenGameAgent.Godot.Samples;
+
+public partial class MinimalLocalAgent : Node
+{
+    public override async void _Ready()
+    {
+        await using var runtime = new GameAgentRuntime(new GameAgentRuntimeOptions(
+            new DeterministicProvider(),
+            "sample-model"));
+        var input = new GameInput(
+            "sample-session",
+            "guide",
+            "player.interaction",
+            "{\"message\":\"Hello from Godot\",\"nearbyObjects\":[\"campfire\"]}",
+            new GameMoment("sample-world", 1),
+            "godot-sample-1");
+
+        var result = await runtime.RunAsync(input);
+        GD.Print($"OpenGameAgent sample completed: {result.Status}");
+    }
+
+    private sealed class DeterministicProvider : IModelProvider
+    {
+        public async IAsyncEnumerable<ModelStreamEvent> StreamAsync(
+            ModelRequest request,
+            [EnumeratorCancellation] CancellationToken cancellationToken)
+        {
+            _ = request;
+            cancellationToken.ThrowIfCancellationRequested();
+            await Task.Yield();
+            yield return ModelStreamEvent.Terminal(new ModelResponse(
+                new AgentContent[] { new TextContent("Welcome to the world.") },
+                ModelStopReason.Stop,
+                new ModelUsage(5, 5)));
+        }
+    }
+}

engines/godot/addons/open_game_agent/examples/minimal_local_agent/README.md

@@ -0,0 +1,5 @@
+# Minimal local agent
+
+Attach `MinimalLocalAgent.cs` to a `Node` in a Godot 4.7 .NET project that imports `OpenGameAgent.Godot.props`, then run the scene. The output panel prints `OpenGameAgent sample completed`.
+
+The sample uses a deterministic provider, requires no API key, and performs no network request.