summer-engine 3.7.0 → 4.0.0

package/library/skills/character-animation-wiring/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: character-animation-wiring
-description: "Wire a rigged, animated character end to end — inspect real clips and bones, locomotion state machine, method-track events, poses, blend shapes, root motion."
+description: "Wire a rigged character end to end: real clips and bones, locomotion states, method tracks, root motion."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: animation
@@ -11,7 +11,7 @@ paths: ["**/*.gd", "**/*.tscn", "**/*.glb"]
 
 # Character Animation Wiring — Rigged GLB to Living Character
 
-The game-critical path: a rigged, animated character lands in the scene — from `summer_generate_3d({options:{rig:true}})` + `summer_generate_motion`, or an imported GLB — and nothing moves yet. This skill wires it end to end: inspect what actually arrived, build locomotion, fire gameplay events off animation frames, add poses and head tracking, key the face, and handle root motion. Then **prove it in a playtest** — a wired tree that was never played is a claim, not a result.
+The game-critical path: a rigged, animated character lands in the scene — from `assets.generate_3d({ ..., rig: true })` + `assets.generate_motion`, or an imported GLB — and nothing moves yet. This skill wires it end to end: inspect what actually arrived, build locomotion, fire gameplay events off animation frames, add poses and head tracking, key the face, and handle root motion. Then **prove it in a playtest** — a wired tree that was never played is a claim, not a result.
 
 Two lanes throughout:
 
@@ -85,7 +85,7 @@ Read the reports. Every later step quotes these exact strings. If the clip list
 ```gdscript
 func run(ctx):
     var character = ctx.find("Goblin")
-    var tree := ctx.anim_state_machine(character, {
+    var tree = ctx.anim_state_machine(character, {
         "states": {"idle": "idle", "walk": "walk", "run": "run"},
         "transitions": [
             ["idle", "walk", {"blend_s": 0.2}],
@@ -150,7 +150,7 @@ func run(ctx):
 Head tracking — one call creates the owned `LookAtModifier3D` under the skeleton:
 
 ```gdscript
-    var mod := ctx.look_at_modifier(skel, ctx.find("Player"), {"bone_name": "Head"})
+    var mod = ctx.look_at_modifier(skel, ctx.find("Player"), {"bone_name": "Head"})
 ```
 
 Unknown props land in `prop_warnings` — read them. Angle limits, influence fade-out by distance, and spine-chain distribution are the difference between alive and possessed: tune per `procedural-animation` (A1/A2).

package/library/skills/character-animation-wiring/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/character-animation-wiring
 kind: skill
 version: 1.0.1
-summary: Wire a rigged, animated character end to end — inspect real clips and bones, locomotion state machine, method-track events, poses, blend shapes, root motion.
+summary: "Wire a rigged character end to end: real clips and bones, locomotion states, method tracks, root motion."
 use_when:
   - a rigged GLB or Meshy rig with generated clips is in the scene and needs idle/walk/run wiring with blend times
   - footstep or attack-frame events, head tracking, still poses, blend-shape facial keys, or root motion must be hooked up

package/library/skills/character-model/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: character-model
-description: "Generate a rigged humanoid — player, NPC, enemy, boss — via T-pose reference, user-gated preview, and Meshy auto-rig, wired as CharacterBody3D or Node3D."
+description: "Generate a rigged humanoid (player, NPC, enemy, boss) from a T-pose reference, previewed before rigging."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: 3d-assets
 user-invocable: true
-allowed-tools: Read Grep summer_search_assets summer_list_my_assets summer_get_asset summer_import_asset_by_id summer_generate_image summer_generate_3d summer_import_from_url summer_add_node summer_set_prop summer_set_resource_property summer_inspect_node summer_inspect_resource summer_get_scene_tree summer_save_scene summer_check_job summer_generate_motion
+allowed-tools: Read Grep summer_assets_search summer_assets_get summer_import_asset_by_id summer_assets_generate_image summer_assets_generate_3d summer_import_from_url summer_add_node summer_set_prop summer_set_resource_property summer_inspect_node summer_inspect_resource summer_get_scene_tree summer_save_scene summer_jobs_wait summer_assets_generate_motion summer_call
 paths: ["assets/characters/**", "assets/models/**", "**/*.tscn", "**/*.gd"]
 ---
 
@@ -16,16 +16,18 @@ This is the canonical auto-rig pipeline. It produces a humanoid `.glb` with a sk
 The whole flow:
 
 ```
-1. T-pose reference image    →  summer_generate_image                          (~10s)
-2. Un-rigged 3D mesh         →  summer_generate_3d(image-to-3d)                (~60s)
+1. T-pose reference image    →  assets.generate_image                          (~10s)
+2. Un-rigged 3D mesh         →  assets.generate_3d(image-to-3d)  → a job       (~60s)
 3. ── USER REVIEW GATE ──
-4. Rigged .glb               →  summer_generate_3d(image-to-3d, rig=true)      (~90s)
+4. Rigged .glb               →  assets.generate_3d(image-to-3d, rig) → a job   (~90s)
 5. Import → editor RESTART → wire as CharacterBody3D / Node3D
 6. Hand off to generate-motion for clips
 ```
 
 The animation skill (`generate-motion`) requires a rigged humanoid; a static `.glb` won't drive motion.
 
+`assets.generate_3d` always answers at once with a job (`{ status: "running", job: { id } }`); `jobs.wait({ jobId, timeoutSeconds: 50 })` follows it, called again until `finished` is true. The finished job's `result` holds the asset ids. Both passes spend the person's credits: `dryRun: true` on any call returns the estimate (`credits`, `balance`, `enough`) and changes nothing.
+
 ## When to use
 
 - "Make a knight character for the player to control."
@@ -46,11 +48,11 @@ The animation skill (`generate-motion`) requires a rigged humanoid; a static `.g
 
 | Role | Tris | Pass via |
 |---|---|---|
-| Hero character (player, close camera) | 8k–15k | `target_polycount: 12000` |
-| Grunt enemy (mid-range, multiple onscreen) | 3k–6k | `target_polycount: 5000` |
-| Crowd / background NPC (LOD-able) | 1k–2k | `target_polycount: 1500` |
-| Mobile-game character | 1k–3k | `target_polycount: 2000` |
-| Cinematic hero (no realtime constraint) | 20k–40k | `target_polycount: 30000` |
+| Hero character (player, close camera) | 8k–15k | `targetPolycount: 12000` |
+| Grunt enemy (mid-range, multiple onscreen) | 3k–6k | `targetPolycount: 5000` |
+| Crowd / background NPC (LOD-able) | 1k–2k | `targetPolycount: 1500` |
+| Mobile-game character | 1k–3k | `targetPolycount: 2000` |
+| Cinematic hero (no realtime constraint) | 20k–40k | `targetPolycount: 30000` |
 
 Pass at the **mesh-generation step** (step 2). The rig pass preserves the topology; you can't reduce polycount after rigging without breaking weights.
 
@@ -61,10 +63,11 @@ Pass at the **mesh-generation step** (step 2). The rig pass preserves the topolo
 The rig pass requires a **front-facing T-pose** with arms out and legs slightly apart. If the reference is in an action pose, the rig will bend wrong and locomotion clips will look broken (knees inverted, elbows snapped — common Meshy failure mode).
 
 ```
-summer_generate_image(
-  prompt="A fantasy knight in full plate armor, red cape, T-pose, arms straight out horizontal, legs slightly apart, front-facing, neutral expression. Game character asset, stylized, clean white background, soft studio lighting, full body in frame, ready for 3D mesh generation.",
-  model="nano-banana-2"
-)
+assets.generate_image({
+  prompt: "A fantasy knight in full plate armor, red cape, T-pose, arms straight out horizontal, legs slightly apart, front-facing, neutral expression. Game character asset, stylized, clean white background, soft studio lighting, full body in frame, ready for 3D mesh generation.",
+  model: "nano-banana-2",
+  aspectRatio: "3:4"
+})
 ```
 
 The phrase `T-pose, arms straight out horizontal, legs slightly apart, front-facing` is load-bearing — drop any of those and the model will drift toward A-pose or a hero stance.
@@ -72,7 +75,7 @@ The phrase `T-pose, arms straight out horizontal, legs slightly apart, front-fac
 If the user already has a concept image in an action pose, re-pose it to T-pose via img2img without re-rolling the design:
 
 ```
-summer_generate_image({
+assets.generate_image({
   referenceImageUrl: "<existing concept image>",
   prompt: "<character> in T-pose, arms extended horizontally, neutral facing camera, white background, clean lighting"
 })
@@ -85,20 +88,20 @@ Show the image to the user:
 ### 2. Generate the un-rigged 3D mesh
 
 ```
-summer_generate_3d(
-  kind="image-to-3d",
-  imageUrl="<image url from step 1>",
-  model="hunyuan",
-  options={ target_polycount: 12000 },
-  wait=true
-)
+assets.generate_3d({
+  kind: "image-to-3d",
+  imageUrl: "<image url from step 1>",
+  model: "hunyuan",
+  targetPolycount: 12000
+})
+jobs.wait({ jobId: "<job.id>", timeoutSeconds: 50 })   // again until finished
 ```
 
-Returns a job result with `assetId` and `fileUrl` — an un-rigged static `.glb`.
+The finished job's `result` has `assetId` and `fileUrl` — an un-rigged static `.glb`.
 Use the asset ID as the stable handle. Import it for preview only:
 
 ```
-summer_get_asset(assetId="<assetId>")
+assets.get({ assetId: "<assetId>" })
 summer_import_asset_by_id(
   assetId="<assetId>",
   path="res://assets/characters/knight_unrigged.glb"
@@ -120,25 +123,25 @@ If the user wants changes, loop back to step 1 or 2. Do NOT silently run the rig
 ### 4. Run the rig pass
 
 ```
-summer_generate_3d({
+assets.generate_3d({
   kind: "image-to-3d",
   imageUrl: "<image url from step 1>",
   rig: true,
-  options: { target_polycount: 12000 }
+  targetPolycount: 12000
 })
+jobs.wait({ jobId: "<job.id>", timeoutSeconds: 50 })   // again until finished
 ```
 
-`rig` is a **top-level boolean argument** on `summer_generate_3d` (the tool also merges it into `options.rig`, so `options: { rig: true }` works too). There is no `polyTarget` — the polycount key is `target_polycount` inside `options`, exactly as in step 2. Related top-level arguments worth knowing here: `riggingHeightMeters` for character height, and `animationNames` / `actionIds` to have the shared animated-character pipeline produce clips in the same job instead of a separate `summer_generate_motion` pass.
+`rig` and `targetPolycount` are plain fields of `assets.generate_3d` (there is no `options` object and no `polyTarget`). Related fields worth knowing here: `riggingHeightMeters` for character height, and `animationNames` / `actionIds` to have the shared animated-character pipeline produce clips in the same job instead of a separate `assets.generate_motion` pass.
 
-Returns a job whose result includes `assetId`, `fileUrl`, and `rigAssetId`.
-If you ran with `wait: false`, poll via `summer_check_job(jobId)`. The
+The finished job's `result` includes `assetId`, `fileUrl`, and `rigAssetId`. The
 `rigAssetId` is the handle `generate-motion` needs — store it.
 Resolve it before import so the agent has the viewer/download metadata:
 
 Import the rigged version, replacing the un-rigged file:
 
 ```
-summer_get_asset(assetId="<rigAssetId>")
+assets.get({ assetId: "<rigAssetId>" })
 summer_import_asset_by_id(
   assetId="<rigAssetId>",
   path="res://assets/characters/knight.glb"
@@ -162,27 +165,28 @@ No programmatic workaround is known. Tell the user, wait, then continue.
 | Pure-visual character (background extra, dialogue head) | `Node3D` | Same as above |
 | Ragdoll-on-death enemy | `CharacterBody3D` while alive, swap to `RigidBody3D` skeleton on death | Two-mode rig; see `procedural-animation` |
 
-Four things the call shapes below encode:
+Three things the call shapes below encode:
 
-- **Every scene-mutating tool takes an explicit `scenePath`** and the scene need not be the active editor tab.
-- **Node paths are relative to that scene's root (`./`)**, not absolute `/root/...` runtime paths.
-- **`summer_set_prop`'s property argument is named `key`**, not `property`.
-- **A `.glb` is instantiated, not assigned.** There is no `scene` property on `Node3D`, and an imported `.glb` is a scene rather than a `Mesh` — on the shipped 4.6.1 binary `ResourceLoader.get_recognized_extensions_for_type("Mesh")` returns `["tres", "mesh", "res"]`, with no `glb`. Use `summer_instantiate_scene`.
+- **Every scene tool, `summer_run_script` included, takes an explicit `scenePath`**, and the scene need not be the active editor tab.
+- **A character is several nodes: build it in one `summer_run_script`**, not a chain of single calls.
+- **A `.glb` is instantiated, not assigned.** There is no `scene` property on `Node3D`, and an imported `.glb` is a scene rather than a `Mesh` — on the shipped 4.6.1 binary `ResourceLoader.get_recognized_extensions_for_type("Mesh")` returns `["tres", "mesh", "res"]`, with no `glb`. Use `ctx.instance_scene` in a script, or `summer_instantiate_scene` for one model.
 
 **CharacterBody3D wiring (player / enemy):**
 
 ```
-summer_add_node(scenePath="res://main.tscn", parent="./World", type="CharacterBody3D", name="Knight")
-summer_set_prop(scenePath="res://main.tscn", path="./World/Knight", key="position", value="Vector3(0, 0, 0)")
-summer_instantiate_scene(scenePath="res://main.tscn", parent="./World/Knight", scene="res://assets/characters/knight.glb", name="Mesh")
-summer_add_node(scenePath="res://main.tscn", parent="./World/Knight", type="CollisionShape3D", name="Collider")
-summer_set_prop(scenePath="res://main.tscn", path="./World/Knight/Collider", key="shape", value="CapsuleShape3D")
-summer_set_resource_property(scenePath="res://main.tscn", nodePath="./World/Knight/Collider", resourceProperty="shape", subProperty="height", value=1.7)
-summer_set_resource_property(scenePath="res://main.tscn", nodePath="./World/Knight/Collider", resourceProperty="shape", subProperty="radius", value=0.4)
-summer_save_scene(scenePath="res://main.tscn")
+summer_run_script(scenePath="res://main.tscn", source="""
+func run(ctx):
+    var knight = ctx.add_node("CharacterBody3D", "Knight", ctx.find("World"), {"position": Vector3(0, 0, 0)})
+    ctx.instance_scene("res://assets/characters/knight.glb", knight, "Mesh")
+    var capsule := CapsuleShape3D.new()
+    capsule.height = 1.7
+    capsule.radius = 0.4
+    ctx.add_node("CollisionShape3D", "Collider", knight, {"shape": capsule})
+    ctx.save_scene()
+""")
 ```
 
-Assigning a bare class name like `"CapsuleShape3D"` to a resource property auto-instantiates it, which is how you get a shape you can then size. `summer_set_resource_property` needs all five of `scenePath`, `nodePath`, `resourceProperty`, `subProperty`, `value`.
+Build the shape as a real resource and size it before you assign it. Later, one size change on that shape is one `summer_set_resource_property` (`nodePath`, `resourceProperty="shape"`, `subProperty`, `value`, plus `scenePath`).
 
 **Node3D wiring (cinematic NPC):**
 
@@ -198,8 +202,8 @@ The imported `.glb` includes its own `Skeleton3D` and `AnimationPlayer` (empty l
 > Knight is wired at `./World/Knight` with an auto-rigged skeleton. `rigAssetId` saved.
 >
 > Next: `generate-motion` to add idle / walk / run / attack
-> clips. Example call: `summer_generate_motion(rigAssetId: "<saved id>",
-> backend: "meshy-library", motionName: "walk")`. For custom actions, use
+> clips. Example call: `assets.generate_motion({ rigAssetId: "<saved id>",
+> backend: "meshy-library", motionNames: ["walk"] })`. For custom actions, use
 > `text-to-motion` (`backend: "text-to-motion"`).
 
 ## Anti-patterns
@@ -220,6 +224,10 @@ The imported `.glb` includes its own `Skeleton3D` and `AnimationPlayer` (empty l
 - **First-person hands-only character.** Generate just hands + forearms in T-pose; rig pass still works. See `fps-controller` for first-person wiring.
 - **Stylized non-human (goblin, orc, halfling).** Works fine as long as the silhouette is bipedal with two arms, two legs, one head. Quadrupeds and centaurs do not.
 
+## Without Summer Engine
+
+In a session without Summer Engine tools (the assets profile; the `summer-assets` skill has the whole loop), do steps 1-4, including the review gate, and stop when the rig pass finishes. Skip steps 5-6 (editor restart, scene wiring). Save the rigged GLB (`rigAssetId`; the unrigged mesh is `assetId`) where the person asked with `out` on `jobs.wait` or `assets.get` (the `summer-assets` skill says how), and tell them the path. Step 7 still applies: `generate-motion` runs without the engine.
+
 ## Fallback (no MCP)
 
 1. Generate the T-pose reference in the Summer dashboard.
@@ -248,4 +256,4 @@ After the rigged character is wired:
 - `asset-strategy` — meta-router; this skill is the canonical drill-down of its "Image-to-3D for characters" path.
 - `prop-model` — for non-character props.
 - `scene-composition` — for the CharacterBody3D + Mesh + Collider parent pattern.
-- `../../references/mcp-tools-reference/mcp-tools-reference.md` — full parameter schemas for `summer_generate_3d`, `summer_generate_image`, and `summer_generate_motion`.
+- `summer_docs_read` id `reference/mcp-tools-reference` — how to call `assets.generate_3d`, `assets.generate_image` and `assets.generate_motion`; `summer_search` returns each one's exact input.

package/library/skills/character-model/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/character-model
 kind: skill
 version: 1.0.2
-summary: Generate a rigged humanoid — player, NPC, enemy, boss — via T-pose reference, user-gated preview, and Meshy auto-rig, wired as CharacterBody3D or Node3D.
+summary: "Generate a rigged humanoid (player, NPC, enemy, boss) from a T-pose reference, previewed before rigging."
 use_when:
   - generating a humanoid character ready for animation — player avatar, NPC, enemy, boss, companion
   - the user asks for a rigged humanoid or a model with a skeleton

package/library/skills/character-movement/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: character-movement
-description: "Player controllers for 2D and 3D, plus the canonical third-person controller for Summer humanoid packages: movement owns translation, clips follow state."
+description: "Player controllers for 2D and 3D, plus the standard third-person controller for Summer humanoids."
 license: MIT
 compatibility: [Cursor, Claude Code, Codex, Windsurf, Gemini, OpenCode]
 category: character-controllers
@@ -248,7 +248,7 @@ func _physics_process(_delta: float) -> void:
 
 Survivors-style games with 200+ agents: enemies are `Area2D` moved with
 `position += dir * speed * delta`, NOT physics bodies. See the `make-game`
-skill's `../make-game/references/2d-survivors.md`. The PLAYER stays a CharacterBody2D.
+skill's survivors blueprint (`summer_docs_read` id `skill/make-game/references/2d-survivors.md`). The PLAYER stays a CharacterBody2D.
 
 ## 3D controller (first + third person)
 
@@ -287,7 +287,7 @@ func _physics_process(delta: float) -> void:
 When the player visual is a Summer character package:
 
 1. Produce or import the package first — it comes from the shared character
-   pipeline (`character-model`; `summer_generate_3d` with rigging and animations)
+   pipeline (`character-model`; `assets.generate_3d` with `rig` and `animationNames`)
    and carries `character.tscn` plus its `character.json` manifest. Instantiate
    `character.tscn`; for clip wiring without this controller see
    `character-animation-wiring`.

package/library/skills/character-movement/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/character-movement
 kind: skill
 version: 1.2.1
-summary: "Player controllers for 2D and 3D, plus the canonical third-person controller for Summer humanoid packages: movement owns translation, clips follow state."
+summary: "Player controllers for 2D and 3D, plus the standard third-person controller for Summer humanoids."
 use_when:
   - building or fixing player movement — gravity, collision, side-scroller, top-down, or 3D walk
   - wiring an imported Summer character package (character.tscn) as the playable third-person player

package/library/skills/character-portrait/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: character-portrait
-description: "Generate a single polished character bust for dialogue UI, character select, lore cards, or codex entries. One character, locked composition, VN-style."
+description: "Generate one polished character bust for dialogue UI, character select, lore cards or codex entries."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: 2d-assets
 user-invocable: true
-allowed-tools: Read Grep Glob Write Edit summer_generate_image summer_search_assets summer_import_from_url summer_set_prop summer_set_resource_property
+allowed-tools: Read Grep Glob Write Edit summer_assets_generate_image summer_assets_search summer_import_from_url summer_set_prop summer_set_resource_property summer_call
 paths: ["assets/**", "art/portraits/**", "ui/portraits/**"]
 ---
 
@@ -62,14 +62,14 @@ background: muted painterly gradient, dark teal to deep brown, no scene detail
 style: semi-realistic painterly, soft edges, oil-painting feel
 ```
 
-Note there is no aspect line. `summer_generate_image` has no size or aspect argument — every MCP image comes back at the server's 1:1 default. Bust framing reads fine square; if the cast needs true portrait framing, generate in the Summer dashboard (which exposes aspect ratio) and bring the results back with `summer_import_from_url`, or crop after. Whichever you pick, do it for the *whole* cast — mixed aspect is as visible as mixed lighting.
+Note there is no aspect line in the anchor: framing is the `aspectRatio` argument of `assets.generate_image`, not prompt text. Bust framing reads fine square (`1:1`, the default); true portrait framing is `aspectRatio: "3:4"`. Whichever you pick, use it for the *whole* cast — mixed aspect is as visible as mixed lighting.
 
 Every subsequent portrait in this cast appends the anchor to the prompt verbatim. **Do not edit the anchor mid-cast** unless the user explicitly says "I want the new ones to look different."
 
 ### 2. Search for an existing portrait
 
 ```
-summer_search_assets(query="<character name> portrait", assetType="2d_image", source="all")
+assets.search({ query: "<character name> portrait", assetType: "2d_image", scope: "all" })
 ```
 
 Reuse beats regenerate. If the user wants to iterate on an existing one, pull its URL and pass it as `referenceImageUrl` for img2img.
@@ -89,16 +89,17 @@ The character description should include: identity (age, build, hair, distinctiv
 > Generating Aria the witch portrait — 1 image (uses credits), model nano-banana-2, anchor locked from `.summer/portrait-anchor.md`. OK?
 
 ```
-summer_generate_image(
-  prompt="Aria, young witch, mid-twenties, pale skin, long black hair with silver streak, sharp green eyes, half-smile, wearing dark indigo robes with silver embroidery, raven on shoulder. <anchor verbatim>",
-  model="nano-banana-2",
-  style="none"
-)
+assets.generate_image({
+  prompt: "Aria, young witch, mid-twenties, pale skin, long black hair with silver streak, sharp green eyes, half-smile, wearing dark indigo robes with silver embroidery, raven on shoulder. <anchor verbatim>",
+  model: "nano-banana-2",
+  style: "none",
+  aspectRatio: "<the cast's framing>"
+})
 ```
 
 `style: "none"` because the anchor's "semi-realistic painterly" already specifies style. Only `cartoon` and `anime` append anything to the prompt, and `realistic` / `none` append nothing — any other value is coerced to `none`. So the preset cannot "fight" a painterly anchor; it just does nothing either way, and every bit of the look has to be in the prompt.
 
-`options={ image_size: ... }` is dropped without an error — see the anchor note above.
+There is no `options` object: shape and size are `aspectRatio`, `width` and `height`.
 
 ### 5. Import and wire into UI
 
@@ -129,12 +130,12 @@ For character-select with multiple portraits, name files consistently: `aria.png
 If the user wants the portrait tweaked ("smaller smile", "darker robes"), use img2img with the existing image as `referenceImageUrl`. Preserves identity and lighting.
 
 ```
-summer_generate_image(
-  prompt="<original prompt> with a smaller, more subtle smile",
-  referenceImageUrl="<previous fileUrl>",
-  model="nano-banana-2",
-  style="none"
-)
+assets.generate_image({
+  prompt: "<original prompt> with a smaller, more subtle smile",
+  referenceImageUrl: "<previous fileUrl>",
+  model: "nano-banana-2",
+  style: "none"
+})
 ```
 
 ## Prompt patterns
@@ -155,7 +156,7 @@ summer_generate_image(
 | `cool warrior portrait` | No identity, no anchor. Returns generic stock art. |
 | `the witch but make her sad` (no img2img ref) | Without `referenceImageUrl`, you get a *different* witch who is sad. Identity drift. |
 | Anchor inconsistent across cast | Each portrait looks like a different game. The cast doesn't read as a cast. |
-| `full body portrait` | "Portrait" implies bust. If you want full body, say so explicitly in the prompt — there is no size argument to reframe with, and full body in a square frame is a different asset class anyway; consider `concept-art` or the 3D pipeline. |
+| `full body portrait` | "Portrait" implies bust. If you want full body, say so explicitly in the prompt and use a tall `aspectRatio` (`2:3`) — full body is a different asset class anyway; consider `concept-art` or the 3D pipeline. |
 | `transparent background` for a painterly portrait | Painterly + transparent fails on most models. Use a flat or gradient background, then alpha-cut in an editor if you must. |
 
 ## Anti-patterns
@@ -173,12 +174,16 @@ summer_generate_image(
 - **Cast of 12+ characters.** Anchor discipline gets harder as fatigue sets in. Print the anchor as a header in your generation script and don't write any prompt without it.
 - **User wants the portrait to "read at small size" (32×32 in a portrait list).** That's pixel-art territory; route to `pixel-art`.
 
+## Without Summer Engine
+
+In a session without Summer Engine tools (the assets profile; the `summer-assets` skill has the whole loop), do steps 1-4 and 6, and skip step 5 (import and UI wiring). Pass `out` with the person's folder so the PNG lands there (the `summer-assets` skill says how), and tell them the path.
+
 ## Fallback (no MCP)
 
 Print the prompt and the call:
 
 ```
-summer_generate_image(prompt="<character + anchor>", model="nano-banana-2", style="none")
+assets.generate_image({ prompt: "<character + anchor>", model: "nano-banana-2", style: "none" })
 ```
 
 Tell the user to run via the Summer dashboard, then `summer_import_from_url` the result to `res://ui/portraits/<name>.png`.
@@ -198,4 +203,4 @@ After the portrait is wired:
 - `concept-art` — explore the look first if not yet locked.
 - `asset-strategy` — meta-router and the 3D pipeline.
 - `scene-composition` — wiring the portrait into a dialogue UI scene.
-- `../../references/mcp-tools-reference/mcp-tools-reference.md` — `summer_generate_image` parameter schema.
+- `summer_docs_read` id `reference/mcp-tools-reference` — how to call `assets.generate_image`.

package/library/skills/character-portrait/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/character-portrait
 kind: skill
 version: 1.0.4
-summary: Generate a single polished character bust for dialogue UI, character select, lore cards, or codex entries. One character, locked composition, VN-style.
+summary: "Generate one polished character bust for dialogue UI, character select, lore cards or codex entries."
 use_when:
   - generating a single polished bust/portrait of a character for dialogue UI, character-select screens, lore cards, or codex entries
   - a dialogue box, party roster, or codex entry needs one consistent face for a named character