feat(programmer): Rbx-only world building, Hub sub-tabs, vision self-probe

Programmer surface: drop the low-level coreai_world_* build APIs (spawn/change/
set_color/destroy/spawn_batch) from persistent mods and the one-off executor via
RegisterWorldEditBuildBindings=false; world building now goes through the Rbx
surface (Instance.new, game/workspace, Vector3/CFrame/Color3), while the WorldEdit
capability still gates Rbx and the read-only coreai_world_find/pos/exists queries
remain. Reworked Programmer.txt / C# fallback / LuaTool / MCP tool descriptions,
the Lua Modding skill and the gallery example Lua to match, and added read_skill(
'Full Lua') for the rarely-needed unity_* reflection backup.

Hub: reusable HubSubTabView/HubSubTabPage; Settings/Token Budget/Statistics grouped
under one AI Settings tab. Vision Detect self-probe (VisionSelfProbe) auto-sets the
vision gate from a synthetic-image round-trip. Lua syntax highlighting in the inline
mod editor. Endpoint editor session-key field relabelled 'Session API key' to avoid
colliding with the HTTP quick-config 'API key'.

Tests: pin RegisterWorldEditBuildBindings=false (build APIs gone, Rbx + queries
survive); re-point endpoint-editor UI tests to the per-row Edit/Remove redesign;
Full Lua skill + Rbx-migrated prompt/skill coverage. 2209/2209 EditMode green.

Author: NeoXider

Assets/CoreAI.Demos/FullAccess/Scripts/FullAccessHubDemoController.cs

@@ -57,24 +57,23 @@ private void Awake()
                 LuaPlatformHubPage.DefaultPageId,
                 () => new LuaPlatformHubPage(ResolveDriver),
                 20);
-            Registry.Register(
-                TokenBudgetHubPage.DefaultPageId,
-                () => new TokenBudgetHubPage(),
-                90);
 
             // WHY: no Chat tab here — this scene keeps its dedicated CoreAiChatUI panel. The Hub is the
-            // tools companion: Settings (the UITK backend config that replaces CoreAiBackendPanel) and
-            // Statistics, both fed live values from the scene scope when available (null-tolerant).
+            // tools companion. Settings, Token Budget and Statistics are grouped under one "AI Settings" tab
+            // as sub-tabs (HubSubTabPage) so the top tab bar stays short; each is fed live scope values when
+            // available (null-tolerant).
             ICoreAISettings settings = ResolveFromCore<ICoreAISettings>();
             InMemoryAiOrchestrationMetrics metrics = ResolveFromCore<InMemoryAiOrchestrationMetrics>();
             Registry.Register(
-                HubSettingsPage.DefaultPageId,
-                () => new HubSettingsPage(settings, chatConfig),
+                "coreai.hub.aisettings",
+                () => new HubSubTabPage(
+                    "coreai.hub.aisettings",
+                    "AI Settings",
+                    100,
+                    new HubSettingsPage(settings, chatConfig),
+                    new TokenBudgetHubPage(),
+                    new HubStatisticsPage(metrics, settings)),
                 100);
-            Registry.Register(
-                HubStatisticsPage.DefaultPageId,
-                () => new HubStatisticsPage(metrics, settings),
-                200);
 
             CoreAiHubWindow window = GetComponent<CoreAiHubWindow>();
             if (window != null)

Assets/CoreAI/CHANGELOG.md

@@ -10,9 +10,27 @@
 - Hub **AI Settings → Vision** override (Auto / On / Off): forces the vision/camera gate on a multimodal
   model whose name the auto-heuristic does not recognise (e.g. a local `qwen3.5` vision build), so the
   camera tool and image sends become usable without renaming the model. (`CoreAISettingsAsset.SetVisionSupport`)
+- Hub **AI Settings → Vision → Detect**: a self-probe sends the model a synthetic image and reads back
+  the answer to decide whether it can actually see, then sets the Vision gate accordingly — so Auto
+  works even for a vision model the name heuristic misses. (`VisionSelfProbe`)
+- Hub **sub-tabs**: a reusable `HubSubTabView` / `HubSubTabPage` groups several pages under one top tab.
+  **Settings / Token Budget / Statistics** are now sub-tabs of a single **AI Settings** tab, keeping the
+  top tab bar short; new sub-tab groupings are one registration.
+- Hub **Lua mod editor** now renders **Lua syntax highlighting** in the inline editor (keywords,
+  strings, numbers, comments) while keeping the field editable. (`LuaSyntaxHighlighter`)
+- Programmer skill **`read_skill('Full Lua')`**: the full `unity_*` reflection surface moved behind an
+  on-demand skill, so it stays available as a rarely-needed backup without bloating the base prompt.
 
 ### Changed
 
+- **The Programmer builds the world Roblox-style only.** The low-level `coreai_world_*` build APIs
+  (`spawn` / `change` / `set_color` / `destroy` / `spawn_batch`) are no longer bound for persistent mods
+  or the one-off `execute_lua` executor; world building goes through the Rbx surface
+  (`Instance.new('Part')`, `game` / `workspace`, `Vector3` / `CFrame` / `Color3`). The read-only queries
+  `coreai_world_find` / `coreai_world_pos` / `coreai_world_exists` remain, and the `WorldEdit` capability
+  still gates the Rbx surface. Prompts, tool descriptions, the Lua Modding skill and the gallery example
+  Lua were updated to match. (`RegisterWorldEditBuildBindings`)
+
 - Hub **API-profiles endpoint editor** redesigned: field visibility is applied on first render (HTTP
   endpoints no longer show LLMUnity-only fields), an **Advanced** foldout hides secondary fields
   (Endpoint ID, context window, ports, slots, secret reference, LLMUnity options), text fields carry

Assets/CoreAI/Docs/LLM_TOOLS.md

@@ -107,6 +107,12 @@ resolved value is `CoreAISettingsAsset.IsVisionEnabled`, surfaced as `CoreAi.IsV
 `CoreAiChatService.IsVisionEnabled()`. **Both** the host send path and tool registration check it; when it
 is `false`, no image is attached and `capture_camera` is not registered.
 
+The Hub **AI Settings** page exposes this as a **Vision** dropdown (Auto / On / Off, backed by
+`CoreAISettingsAsset.SetVisionSupport`). Use **On** to force the gate open for a multimodal model whose
+name the `Auto` heuristic does not recognise (e.g. a local `qwen3.5` vision build), so the camera tool and
+image sends become usable without renaming the model; use **Off** to hard-disable vision on a model the
+heuristic would otherwise treat as vision-capable.
+
 ### Host send path (camera → model)
 
 The provider-safe one-shot path: capture a camera and send it as a single **user** message

Assets/CoreAI/Runtime/Core/Features/AgentPrompts/BuiltInAgentSystemPromptTexts.cs

@@ -39,12 +39,10 @@ internal static class BuiltInAgentSystemPromptTexts
         internal const string Programmer =
             "You are the Programmer agent for the CoreAI Lua sandbox (Lua-CSharp runtime). " +
             "Use the execute_lua tool to run Lua code; use manage_mods (list/get_source/load/reload/unload) for persistent mods with hooks. " +
-            "Answer plain questions, greetings, and one-off replies directly - do NOT call read_skill or any tool for those. Only when the task actually needs the deeper API (a game loop, timers, cross-mod communication, input handling), call read_skill('Lua Modding') once first - it returns the full API reference with worked examples; the list below is only the survival minimum. For Roblox-style scripts (Instance.new, game/workspace, Vector3/CFrame/Color3, Part properties), call read_skill('Rbx API') instead. " +
-            "Typical globals when the game wires them: report(msg), logic_list(), logic_define(name, fn), logic_reset(name) for game-rule slots; " +
-            "coreai_world_spawn({prefab,name,x,y,z,rx,ry,rz,scale,scaleX,scaleY,scaleZ,parent}), coreai_world_change(name,{x,y,z,rx,ry,rz,scale,scaleX,scaleY,scaleZ,parent}), coreai_world_set_color, and coreai_world_destroy for world changes. Call logic_list() when unsure which rule slots exist. " +
-            "Full Lua Mode skill: when Full is enabled, use unity_* APIs only after a one-shot diagnostic execute_lua call, read its Success/Output/Error, then load or reload a persistent mod if needed. " +
-            "For scene objects prefer unity_list_objects(max), unity_find_all(pattern,max), unity_find_by_tag(tag,max), unity_find_by_component(type,max), unity_describe_object(id), unity_get_transform(id), unity_set_position(id,x,y,z), unity_set_rotation_euler(id,x,y,z), unity_set_scale(id,x,y,z), unity_parent(child,parent,worldPositionStays), unity_get_children(id), unity_list_components(id), unity_get_member(id,component,member), unity_set_member(id,component,member,value), and unity_call(id,component,method,args). " +
-            "WorldEdit APIs do not require Full mode; for visible spawns, call coreai_world_list_prefabs first, then coreai_world_spawn({ prefab='key', name='objectName', x=0, y=0, z=0 }) or coreai_world_spawn_batch with a real prefab key; primitives 'cube'/'sphere'/'cylinder'/'capsule'/'plane'/'empty' also work as prefab keys; report() alone is not a spawn. " +
+            "Answer plain questions, greetings, and one-off replies directly - do NOT call read_skill or any tool for those. Only when the task actually needs the deeper API (a game loop, timers, cross-mod communication, input handling), call read_skill('Lua Modding') once first - it returns the full API reference with worked examples; the list below is only the survival minimum. For building anything visible in the world - parts, models, whole scenes - call read_skill('Rbx API') and build Roblox-style: Instance.new('Part'), game/workspace, Vector3/CFrame/Color3, Part properties. The Rbx surface is THE way to create and edit world objects. " +
+            "Typical globals when the game wires them: report(msg), logic_list(), logic_define(name, fn), logic_reset(name) for game-rule slots. Call logic_list() when unsure which rule slots exist. " +
+            "To inspect the existing scene use the read-only queries coreai_world_find(pattern), coreai_world_pos(name), and coreai_world_exists(name) - good for locating objects including the camera. A report() line alone is not a scene change. " +
+            "Full reflection (unity_* scene APIs) is a rarely-needed backup - when a task truly needs it, call read_skill('Full Lua') first. " +
             "Inside mods you also have: hooks_every(seconds, fn) repeating timers (min 0.05s) and hooks_on('tick', fn) per-frame alias for game loops; store_set(key, value)/store_get(key) per-mod persistent strings (survive restarts); events_emit(name, payload) to other mods and hooks_on(name, function(evt, payload) ... end) to receive; mods_export(name, valueOrFn), mods_get(otherModId, name), mods_call(otherModId, fnName, ...), mods_list_exports(otherModId) for cross-mod variables and function calls (values copy by value, primitives and plain tables only); input_key('a')/input_key_down/input_key_up, input_mouse_button(0), input_mouse_x()/input_mouse_y(), input_axis('Horizontal') to read player input (poll held keys from timers - whole game loops like a falling-blocks game are possible in one mod). " +
             "Do not hard-code visual recipes: inspect the scene/components first, then use the smallest real API that matches the host. " +
             "Do not invent Lua globals; if a helper is not listed by the task, tool contract, or logic_list/world docs, do not call it. " +

Assets/CoreAI/Runtime/Core/Features/AgentPrompts/BuiltInFullLuaSkillText.cs

@@ -0,0 +1,69 @@
+namespace CoreAI.Ai
+{
+    /// <summary>
+    /// Built-in "Full Lua" skill: the model-facing reference for the Full-tier reflection surface
+    /// (<c>unity_*</c> scene APIs), loaded on demand via <c>read_skill</c>. Mirrors
+    /// <see cref="BuiltInLuaModdingSkillText"/>: the Programmer prompt only names the skill as a
+    /// rarely-needed backup; this text carries the whole reference. An optional
+    /// <c>Resources/AgentSkills/FullLua</c> TextAsset overrides <see cref="Instructions"/>.
+    /// </summary>
+    public static class BuiltInFullLuaSkillText
+    {
+        /// <summary>Catalog name (what the model passes to <c>read_skill</c>).</summary>
+        public const string SkillName = "Full Lua";
+
+        /// <summary>One-line catalog description shown before the model decides to read the skill.</summary>
+        public const string SkillDescription =
+            "Full-tier reflection over arbitrary scene objects and components: unity_list_objects/" +
+            "unity_find_*/unity_describe_object, transform setters, unity_get_member/unity_set_member/" +
+            "unity_call. A rarely-needed backup for tasks the Rbx surface and Lua mechanics cannot " +
+            "cover; requires Full mode to be enabled. Read only when a task truly needs raw reflection.";
+
+        /// <summary>Full instructions returned by <c>read_skill("Full Lua")</c>.</summary>
+        public const string Instructions = @"# CoreAI Full Lua Reference (Full-tier reflection)
+
+Full mode exposes raw reflection over every GameObject and component in the scene. It is a
+BACKUP surface: prefer the Rbx API (read_skill('Rbx API')) for building and the standard mod
+mechanics (hooks/timers/store/input) for behaviour. Use Full only when a task truly needs to
+inspect or mutate arbitrary existing scene objects. These APIs are available only when the host
+enabled Full mode; otherwise every unity_* call is absent.
+
+## Workflow
+
+First run a small diagnostic execute_lua script: inspect the scene, return a compact string or
+JSON through return/report, then read Success/Output/Error BEFORE changing anything or loading a
+persistent mod. Do not hard-code one recipe for visual requests: inspect objects/components
+first, then use the smallest real API that matches the scene.
+
+## Discovery
+
+- `unity_list_objects(max)` -> root objects with ids.
+- `unity_find_all(pattern, max)` -> objects whose name matches the pattern.
+- `unity_find_by_tag(tag, max)`; `unity_find_by_component(type, max)`.
+- `unity_describe_object(id)` -> name, tag, active state, components.
+- `unity_get_children(id)`; `unity_list_components(id)`.
+
+## Transforms
+
+- `unity_get_transform(id)` -> position/rotation/scale.
+- `unity_set_position(id, x, y, z)`; `unity_set_rotation_euler(id, x, y, z)`;
+  `unity_set_scale(id, x, y, z)`.
+- `unity_parent(childId, parentIdOr0, worldPositionStays)` — parentId 0 unparents.
+
+## Members & methods
+
+- `unity_get_member(id, component, member)` / `unity_set_member(id, component, member, value)`.
+- `unity_call(id, component, method, args)` — invoke a component method with an args table.
+
+## Example diagnostic
+
+```lua
+local objs = unity_find_all('Enemy', 10)
+local names = {}
+for i, o in ipairs(objs) do names[i] = o.name .. ':' .. o.id end
+report(table.concat(names, ','))
+```
+Read the Output, pick the exact ids, and only then apply the smallest mutation
+(unity_set_position / unity_set_member) that fulfils the request.";
+    }
+}

Assets/CoreAI/Runtime/Core/Features/AgentPrompts/BuiltInFullLuaSkillText.cs.meta

@@ -48,20 +48,17 @@ and type annotations/casts all work. Plain Lua 5.2 is unaffected.
 
 ## 2. World API (WorldEdit tier - no Full mode needed)
 
-- `coreai_world_list_prefabs()` -> table of prefab keys. Call before the first spawn.
-- `coreai_world_spawn({prefab='key', name='obj1', x=0,y=0,z=0, rx=0,ry=0,rz=0,
-   scale=1 or scaleX/scaleY/scaleZ, parent='optionalParentName'})`
-  Primitives work as prefab keys: 'cube','sphere','cylinder','capsule','plane','empty'.
-- `coreai_world_change(name, {x=,y=,z=, rx=,ry=,rz=, scale=, parent=})` - move/rotate/rescale.
-- `coreai_world_set_color(name, '#RRGGBB')`
-- `coreai_world_destroy(name)`; `coreai_world_exists(name)` -> bool
-- `coreai_world_spawn_batch(list)` and `coreai_world_grid` for many objects at once.
-- Transactions: `coreai_world_begin_transaction()` / `commit` / `rollback` to group edits.
-- Names are the contract: pick unique names at spawn and drive everything by name afterwards.
+World BUILDING (creating, moving, recoloring, destroying objects) is done Roblox-style:
+`Instance.new('Part')`, `game`/`workspace`, `Vector3`/`CFrame`/`Color3`, and Part properties
+(Position, Size, Color, Anchored, Parent = workspace). Call `read_skill('Rbx API')` for the
+full reference before building anything visible - there is no other world-building surface.
 
 ## 3. Scene queries (read-only, no Full mode needed)
 
-- `coreai_world_count_objects()`, `coreai_world_find(name)`, `coreai_world_get_transform(name)`
+- `coreai_world_find(pattern)` -> list of scene object names containing the pattern
+  (case-insensitive substring match, at most 100 results).
+- `coreai_world_pos(name)` -> `{x=,y=,z=}` table, or nil when the object does not exist.
+- `coreai_world_exists(name)` -> bool.
   (availability depends on host wiring - if a query global is nil, fall back to unity_* under Full).
 
 ## 4. Full tier (only when the host enabled Full Lua)
@@ -75,7 +72,7 @@ and type annotations/casts all work. Plain Lua 5.2 is unaffected.
   `unity_parent(childId, parentIdOr0, worldPositionStays)`
 - `unity_get_member(id,component,member)`, `unity_set_member(id,component,member,value)`,
   `unity_call(id,component,method,argsTable)`
-Prefer coreai_world_* for plain transforms even in Full mode - it is cheaper and logged.
+Prefer the Rbx surface (Part.Position / Part.CFrame) for plain transforms even in Full mode.
 
 ## 5. Timers & game loops (inside mods)
 
@@ -135,42 +132,45 @@ fired an exact number of times - count what actually happened.
 
 ## 11. Complete mod example - miniature falling-block game
 
-Shows: spawn, color, per-load unique names, input with edge detection, gravity accumulator,
-store persistence, an event another mod (or the host) can send.
+Shows: Rbx-style build (Instance.new / workspace), reload-safe root, input with edge
+detection, gravity accumulator, store persistence, an event another mod (or the host) can send.
 
 ```lua
--- Per-load generation suffix: Unity destroys deferred (end of frame), so a reload that
--- destroys the old objects and spawns identical names in the same frame would collide.
-local gen = (tonumber(store_get('gen')) or 0) + 1
-store_set('gen', tostring(gen))
-local ROOT = 'MiniGameRoot_g' .. gen
-local prev = 'MiniGameRoot_g' .. (gen - 1)
-if coreai_world_exists(prev) then coreai_world_destroy(prev) end
-coreai_world_spawn({ prefab = 'empty', name = ROOT, x = 0, y = 0, z = 0 })
+-- Reload-safe root: drop the previous generation before building this one.
+local prev = workspace:FindFirstChild('MiniGameRoot')
+if prev then prev:Destroy() end
+local root = Instance.new('Model')
+root.Name = 'MiniGameRoot'
+root.Parent = workspace
 
 local score = tonumber(store_get('score')) or 0
-local px, py = 0, 10
-coreai_world_spawn({ prefab = 'cube', name = ROOT .. '_p', parent = ROOT, x = px, y = py, z = 0 })
-coreai_world_set_color(ROOT .. '_p', '#00CCFF')
+local px, py = 0, 40                              -- studs (1 stud = 0.28 m)
+local player = Instance.new('Part')
+player.Name = 'MiniGamePlayer'
+player.Size = Vector3.new(4, 4, 4)
+player.Position = Vector3.new(px, py, 0)
+player.Color = Color3.fromHex('#00CCFF')
+player.Anchored = true
+player.Parent = root
 
 local was_w = false
 hooks_every(0.05, function()                      -- input at 20 Hz
-  if input_key('a') and px > -4 then px = px - 1 end
-  if input_key('d') and px <  4 then px = px + 1 end
+  if input_key('a') and px > -16 then px = px - 4 end
+  if input_key('d') and px <  16 then px = px + 4 end
   local w = input_key('w')                        -- derived edge, never input_key_down here
   if w and not was_w then score = score + 1 end
   was_w = w
-  coreai_world_change(ROOT .. '_p', { x = px, y = py, z = 0 })
+  player.Position = Vector3.new(px, py, 0)
 end)
 
 local acc = 0
 hooks_every(0.1, function()                       -- gravity with accumulator
   acc = acc + (input_key('s') and 5 or 1)
   if acc < 5 then return end
   acc = 0
-  py = py - 1
+  py = py - 4
   if py <= 0 then
-    py = 10
+    py = 40
     score = score + 10
     store_set('score', tostring(score))
     report('landed, score=' .. score)
@@ -196,7 +196,8 @@ fired an exact number of times - count what actually happened.
 - hooks_every interval below 0.05 s is clamped - do not rely on faster timers.
 - report() shows nothing: report logging is disabled for the mod by default - it is a host
   switch, not an error; state still changes.
-- A spawn you cannot see: wrong prefab key - call coreai_world_list_prefabs() first;
-  primitives 'cube'/'sphere'/'cylinder'/'capsule'/'plane'/'empty' always work.";
+- A Part you cannot see: set .Parent (usually workspace) after configuring it and set
+  Anchored = true; remember coordinates are in STUDS (1 stud = 0.28 m), so meter-sized
+  numbers build a tiny scene.";
     }
 }