AI tools: Editor and jobs

Editor state, layouts, long-running jobs and settings. 33 tools. You see every step your AI takes and can undo any of them.

begin_rehearsal

Open a practice copy of the scene. Until merged, your changes go there, not into the real scene. The person sees it live.

capability_ledger

What TTR can really do: each engine capability (flight, ocean, terrain, faces, crowds…) scored on six criteria (looks, behaves, understood by agents, in budget, survives variation, reusable) with the tests behind it and its gaps. Read it before planning a game or a new mini-world: reuse what's verified, build what's missing.

capability_request

Record a capability you needed and the engine lacked (or had only in part), so it gets built: what (a capability_ledger id or a short name), why (what the game wanted to do) and which game. Appended to the project's capability_requests.json with your name and the date; list shows what has been asked for. Record it, then carry on with the best workaround.

discard_rehearsal

Throw away the open rehearsal. The real scene is unchanged.

No arguments.

edit_intersection

Change how an intersection is controlled: signals, an all-way stop, yield, none, or auto (back to the rule). Pick it by `junction` number (road_report lists them) or the point `at` [x, z] nearest it. Signal timing (green, amber, all_red seconds) applies to the whole network. One undo step.

edit_key

The curve editor: change one key of a sequence track without retyping it. tangents: auto (smooth, never overshooting), flat (eases in and out: a hold), linear, step, free (with in/out slopes, units per second, one per number). ease (to the next key) with any preset: auto, linear, step, smooth, ease_in/out/in_out, ease_in/out/in_out_cubic, ease_in/out/in_out_expo, ease_in_back, ease_out_back, ease_out_elastic, ease_out_bounce, bezier [x1,y1,x2,y2]. move_to: drag the key to another time. channel: position, rotation, scale, weight (keys for property tracks). sample: n returns the curve's points ("position.y" for one number) to read its shape.

edit_road

Change a road: any of its fields (type, lanes, speed, one-way, bridge, control, markings, props, banking), its points (replace all; insert, move or delete one), or remove it. The network rebuilds around it (intersections, lanes, land). One undo step.

editor_command

Run one of the editor's own commands, exactly as the person's shortcut or command palette (⌘K) would: tools (tool.move, tool.rotate, tool.scale), gizmo axes and pivot, grid/angle/scale/surface snapping, duplicate (and duplicate along), align, distribute, drop to surface, attach/detach, Game View, frame, Play from here... list: true returns every command with its id, title, group and current shortcut (people can rebind them). view.frame frames the selection (or safely resets if none); view.reset always teleports the person's camera outside scene geometry, even when Follow AI is off. Other commands act on the current selection; select objects first with select.

editor_press

Press a control in the editor by what the person reads on it (a button's title, its tooltip, its label), the way a click would, after bringing a dock panel forward if you name one. Try a manual tool by hand, check a panel's buttons work, or do a Teach Me step for the person. Then editor_window_shot to see what it did. Publishing, uploading, signing out, quitting and buying stay the person's to press.

editor_visibility

Hide, isolate or lock objects in the editor only, to work inside a busy level: hidden ones aren't drawn while editing, locked ones can't be clicked in the viewport. Everything attached to an object goes with it. Never saved in the scene; Play and exports show everything. action list (the default) says what's hidden and locked.

editor_window_shot

A picture of the editor window as the person sees it: toolbar, dock panels, Inspector, status bar. Name a panel to bring it forward first (scene, inspector, content, history, profiler, animation, input, mixer, playtest, output, agent…). Check the real UI by eye: a panel you changed, a Teach Me step, what the person is looking at. The 3D view is drawn as the viewport shows it, with the activity feed and the Teach Me card over it.

hand_off

A keyed hand-off: the other hand reaches and closes on the object at `point` while the first still holds it, then the first opens and draws back; the object goes to the second hand at the grasp. Saved as a clip with the object's track and played.

history

Recent changes: who made them (you or an agent), what and to which object. Undone changes are marked.

lane_parts

Why the lane graph traffic drives is in pieces: its strongly connected parts (inside one, every segment reaches every other), the biggest first. For each part besides the biggest: its size, where it is, the roads in it, and its boundary: the lanes leading in from outside, the lanes leading out, and dead ends inside. A part with ways in and none out is a TRAP (cars go in and never come back), one with ways out and none in a SOURCE, neither an ISLAND. Fix the plan or the junction there, then rebuild_roads and look again.

merge_rehearsal

Apply the rehearsal's changes to the real scene as one undoable step. Run run_tests first.

No arguments.

node_graph

Visual scripting (the node graph people wire by hand in Tools › View › Node Graph): read, write and compile graphs. A graph is JSON in Scripts/<name>.graph.json: {name, nodes:[{id, type, x, y, values:{pin: value}}], links:[{from, fromPin, to, toPin}], comments:[{text,x,y,width,height}]}; it compiles to Scripts/<name>.js, the same kind of script the kits use (attach it with a script component; On Touch needs a trigger). action catalog: every node type with its pins (white exec pins order the steps; value pins carry numbers, text, objects, true/false). read: a graph's JSON. write: save a graph (graph object) and compile it, returns the warnings and the JavaScript. compile: the JavaScript for a graph without saving. example: writes the door_with_key and key_pickup graphs (a door that opens for the player carrying a key, and the key).

query_lanes

Read the lane graph traffic and racers drive: lanes near a point (`at`), a junction's lanes and turns (`junction`), or the lane route between two points (`from`, `to`) with its length and the stops on it. Lanes are centerlines in travel direction with speed (km/h), width, what follows each, and stop lines with their control. Set `points` true to get the lane polylines.

read_script

Read a gameplay script from the Scripts folder, or list them all when no file is given.

rehearsal_status

What the open rehearsal has changed compared with the real scene.

No arguments.

remove_requirement

Remove a requirement by id: from the open scene's game brief when it has that id, else from the Game Plan (unprotected only; protected ones are the person's and can't be removed by agents).

set_focus_key

The focus puller: from t the sequence's camera focuses on `on` (a place: an object; a character's eyes by default, the nearer eye; {of, bone: "eyes" | "eye_l" | "eye_r" | "head" | a node}; a point) or at `distance` metres, racking there over `rack` seconds (default 0.6; 0 a snap) with ease (default smooth), the focus ring turned evenly in diopters as a real follow-focus. A moving subject stays sharp. Cuts that set their own focus or focus_distance keep it. Needs an iris (a lens_kit, or aperture). remove: true deletes the cue at t.

set_key

Set a key on a sequence track (making the track if needed): position [x,y,z], rotation (Euler degrees [x,y,z] or a quaternion [x,y,z,w]) and/or scale for an object (or a bone), or value for a property track. ease shapes the stretch to the next key: auto (default), linear, step, smooth, ease_in, ease_out, bezier (with bezier [x1,y1,x2,y2]), cubic (with in/out slopes). falloff (seconds) moves the keys around it too, fully at t and less further away: one edit reshapes a recorded arc smoothly (raise its peak, move where it lands). remove: true deletes the key at t.

set_patrol

Set a brain's ordered patrol route, with per-point pauses and look-around angles. Accept waypoint names/#ids or position triples, as strings or objects. Validates names before changing anything; an empty route holds position. Preset, senses and squad stay unchanged. Undoable; authoring scene/rehearsal only.

set_team

Atomically assign existing brains to a named squad and explicit leader/roles. Validates every entity and protected-scene lock before one undoable CommandGroup; never partially assigns a team. Does not change recipes or movement. Empty squad makes members independent. Refuses during Play.

set_time_scale_key

Key how fast story time runs in a sequence (1 real time, 0.15 slow motion, 0.01...10): a ramp 1 → 0.15 → 1 is three or four keys (ease "smooth" eases into and out of it). While it plays, physics, animation, particles and scripts' clocks slow together; keys stay in story time. Reports how long the sequence now takes to watch.

set_ui_theme

Patch the game UI theme: six-digit hex background/panel/foreground/muted/accent/danger/success, fontSize 18...32, safeInset 16...80, pack (a theme pack name), packs (the game's packs or overrides) and scenes (scene name: pack). ui_theme lists, edits and previews packs. Text contrast/readability should still be visually reviewed.

set_waypoint

While the game plays: set the GPS waypoint (x, z in metres) that the minimap routes to along the road lanes from the player (or the car it drives), or clear it (clear: true). The route is worked out again every second and cleared on arrival. Scripts do the same with game.ui("waypoint", {x, z}).

set_wear

Change how worn a forged object looks, without changing its recipe: wear (0 new, 1 as forged, 2 much more: chipped edges, rubbed-through hand spots, kicks, scuffs), age_years (stains, dirt, fade, dust grow with it), chip_size, grime, fade (sun), scratches; Pro: edge_width, dust. Values you leave out keep their current setting. One undoable step; the person sees the object change. explain: true lists the current settings and the object's parts (names and centres) for paint_wear_mask, changing nothing. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

set_wind

Set the scene's wind for plants: trees, bushes, hedges and grass sway with it and gusts roll across lawns (direction = compass degrees it blows toward, speed m/s: 2 breeze, 6 windy, 12 gale; gusts 0...1).

teach

Teach the person how to do something in the Arcwright editor, on the real editor: each step lights up the actual control with one sentence and waits for them to do it (it moves on by itself when the editor sees it done; the card always has Do it for me and Skip). Use it when they ask how to do something by hand ("teach me", "show me how", "how do I…"), instead of describing menus in chat or doing it for them. lessons: the built-in lessons. start: a lesson by id, or the one that fits about ("make a zombie chase me"), or your own lesson (title + steps: target = a panel (viewport, scene, inspector, content, history, agent, quicktools, nodegraph, workshop, tools, timeline, camera, gameui), a control's label or tooltip as it reads on screen ("Play", "Quick Tools", "Add a cube"), "panel/label", or an object in the world ("object:Crate_1", "object:selected"); say = one sentence; wait = select, add, change, play, stop, save, shows (the next step's control appeared) or agent, or none for Next; do = click, editor.play, editor.stop, editor.save, editor.add_cube, editor.select, or a tool name with args, where "$selection" is the selected object). point: light up one control with a caption, nothing to wait for. status: which step they're on. stop: end it. Keep lessons to 3 or 4 steps.

tool_job

Read a long-running HTTP tool job by job_id. States: queued, running, completed, failed, cancelled. Poll this receipt instead of repeating the original tool. Completed replies include the original tool result. Receipts are scoped to the MCP session and saved on disk for reconciliation.

tour

The guided tour of the Arcwright editor (2-3 minutes) that you give the person live. status: whether to offer it now (only on the first connection of this install). offered: record that you offered it (call after asking, whatever the answer). script: the steps with what to highlight, what to say and which tools to use — follow it only after the person said yes. highlight: spotlight an editor area with a caption (panel: viewport, scene, inspector, assets, forge, history, agent, play, toolbar). clear: remove the spotlight. finish: end the tour.

viewport_input

Test the editor's navigation like a person would: plays a mouse or trackpad gesture into the viewport (drag to slide the view, option-drag or middle-drag to orbit, scroll to zoom, click to select) frame by frame, without moving the real pointer, and measures it: which view the click landed on, how far the camera moved and turned, and how many pixels the grabbed point drifted from under the pointer. Camera gestures only: it refuses a drag that would start on the move gizmo, any gesture during Play, and left-button gestures (drag, orbit, click) while Sculpt Mode or a paint brush is on.