diff --git a/api/routers/agent.py b/api/routers/agent.py
index 3eeb2a73..055b76bf 100644
--- a/api/routers/agent.py
+++ b/api/routers/agent.py
@@ -1,12 +1,15 @@
 """
 Agent chat endpoint — runs an Ollama-powered tool-use loop against Modly's API.
 """
+import json
 import re
 import uuid
 import httpx
 from fastapi import APIRouter
 from pydantic import BaseModel
 
+import services.generator_registry as reg_module
+
 router = APIRouter(prefix="/agent", tags=["agent"])
 
 MODLY_API = "http://localhost:8765"
@@ -408,6 +411,60 @@ def _extract_thinking(msg: dict) -> tuple[str, str | None]:
     return content, thinking
 
 
+def _read_glb_modly_extras(glb_path) -> dict | None:
+    """Parse a GLB's leading JSON chunk and return asset.extras.modly, if present.
+    Used only as a fallback for assets that predate the .tags.json sidecar."""
+    try:
+        with open(glb_path, "rb") as f:
+            header = f.read(12)
+            if len(header) < 12 or header[0:4] != b"glTF":
+                return None
+            chunk_header = f.read(8)
+            if len(chunk_header) < 8 or chunk_header[4:8] != b"JSON":
+                return None
+            chunk_length = int.from_bytes(chunk_header[0:4], "little")
+            doc = json.loads(f.read(chunk_length))
+            return (doc.get("asset") or {}).get("extras", {}).get("modly")
+    except Exception:
+        return None
+
+
+def _load_asset_meta(workspace_rel_path: str) -> dict | None:
+    """Resolve name/project/tags/lineage for the model currently in the viewer.
+
+    Reads the .tags.json sidecar when present, falling back to the GLB's own
+    embedded extras.modly for name/project/tags. Lineage (derived_from) is only
+    ever written to the sidecar, so an asset with no sidecar has none to report.
+    """
+    workspace_dir = reg_module.WORKSPACE_DIR.resolve()
+    abs_path = (workspace_dir / workspace_rel_path).resolve()
+    if not str(abs_path).startswith(str(workspace_dir)):
+        return None  # escapes the workspace — refuse to read
+
+    sidecar_path = abs_path.with_suffix(".tags.json")
+    if sidecar_path.exists():
+        try:
+            data = json.loads(sidecar_path.read_text(encoding="utf-8"))
+            return {
+                "name": data.get("name"),
+                "project": data.get("project"),
+                "tags": data.get("tags") or [],
+                "derived_from": data.get("derived_from"),
+            }
+        except Exception:
+            pass  # malformed sidecar — fall through to the GLB fallback
+
+    modly = _read_glb_modly_extras(abs_path)
+    if modly:
+        return {
+            "name": modly.get("name"),
+            "project": modly.get("project"),
+            "tags": modly.get("tags") or [],
+            "derived_from": None,
+        }
+    return None
+
+
 @router.get("/models")
 async def list_ollama_models(ollama_url: str = "http://localhost:11434"):
     async with httpx.AsyncClient(timeout=5.0) as client:
@@ -431,6 +488,30 @@ async def agent_chat(request: AgentChatRequest):
             ctx_lines.append(f"Current mesh path: {request.context['currentMeshPath']}")
         if request.context.get("meshTriangles"):
             ctx_lines.append(f"Current mesh triangles: {request.context['meshTriangles']:,}")
+        if request.context.get("currentClipName"):
+            ctx_lines.append(f"Current animation clip: {request.context['currentClipName']}")
+        if request.context.get("availableClips"):
+            ctx_lines.append(f"Available animation clips: {', '.join(request.context['availableClips'])}")
+
+        mesh_path = request.context.get("currentMeshPath")
+        meta = _load_asset_meta(mesh_path) if mesh_path else None
+        if meta:
+            if meta.get("name"):
+                ctx_lines.append(f"Model name: {meta['name']}")
+            if meta.get("project"):
+                ctx_lines.append(f"Project: {meta['project']}")
+            if meta.get("tags"):
+                ctx_lines.append(f"Tags: {', '.join(meta['tags'])}")
+            derived = meta.get("derived_from")
+            if derived:
+                parent = derived.get("parent") or {}
+                root = derived.get("root") or {}
+                parent_label = parent.get("name") or parent.get("path")
+                root_label = root.get("name") or root.get("path")
+                if parent_label == root_label:
+                    ctx_lines.append(f"Derived from: {parent_label}")
+                else:
+                    ctx_lines.append(f"Derived from: {parent_label} (originally: {root_label})")
         if ctx_lines:
             messages.append({
                 "role": "system",
diff --git a/electron/main/artifact-registry-service.test.ts b/electron/main/artifact-registry-service.test.ts
index 882120d4..0fa5f191 100644
--- a/electron/main/artifact-registry-service.test.ts
+++ b/electron/main/artifact-registry-service.test.ts
@@ -10,6 +10,7 @@ import {
   normalizeWorkspaceAssetPath,
   openWorkspaceAssetLibraryEntry,
   readWorkspaceAssetLibraryEntry,
+  readWorkspaceAssetLibraryThumbnail,
   registerWorkspaceAssetLibraryIpcHandlers,
 } from './artifact-registry-service.ts'
 
@@ -22,7 +23,8 @@ async function withWorkspace(run: (workspaceDir: string) => Promise<void>) {
   }
 }
 
-test('normalizes only workspace-relative paths under allowed Workflows and Exports roots', () => withWorkspace(async (workspaceDir) => {
+test('normalizes only workspace-relative paths under allowed model roots', () => withWorkspace(async (workspaceDir) => {
+  assert.equal(normalizeWorkspaceAssetPath(workspaceDir, 'Default/hero.glb').workspacePath, 'Default/hero.glb')
   assert.equal(normalizeWorkspaceAssetPath(workspaceDir, 'Workflows/checkpoints/hero.glb').workspacePath, 'Workflows/checkpoints/hero.glb')
   assert.equal(normalizeWorkspaceAssetPath(workspaceDir, 'Exports/hero.glb').workspacePath, 'Exports/hero.glb')
   assert.throws(() => normalizeWorkspaceAssetPath(workspaceDir, '../secret.glb'), /traversal|escape|relative/i)
@@ -64,6 +66,49 @@ test('lists Workflows and Exports assets while skipping hidden, cache, and inter
   assert.equal(result.success && result.entries.find((entry) => entry.workspacePath.endsWith('exported.ply'))?.openable, false)
 }))
 
+test('indexes generated models and reads project, structural tags, creation time, and lineage from model sidecars', () => withWorkspace(async (workspaceDir) => {
+  await mkdir(path.join(workspaceDir, 'Default'), { recursive: true })
+  await mkdir(path.join(workspaceDir, 'Exports/adventure'), { recursive: true })
+  await writeFile(path.join(workspaceDir, 'Default/hero.glb'), 'glb')
+  await writeFile(path.join(workspaceDir, 'Default/hero.tags.json'), JSON.stringify({
+    name: 'Hero',
+    project: null,
+    tags: ['mid-poly'],
+    created: '2026-06-15T10:00:00.000Z',
+  }))
+  await writeFile(path.join(workspaceDir, 'Exports/adventure/hero-rigged.glb'), 'glb')
+  await writeFile(path.join(workspaceDir, 'Exports/adventure/hero-rigged.tags.json'), JSON.stringify({
+    name: 'Hero Rigged',
+    project: 'Adventure',
+    tags: ['rigged', 'animated', 'clip-hero-walk', 'mid-poly'],
+    created: '2026-06-16T10:00:00.000Z',
+    derived_from: {
+      parent: { path: 'Default/hero.glb', name: 'Hero' },
+      root: { path: 'Default/hero.glb', name: 'Hero' },
+    },
+  }))
+
+  const result = await listWorkspaceAssetLibrary({ workspaceDir })
+  assert.equal(result.success, true)
+  if (!result.success) return
+  assert.deepEqual(result.entries.map((entry) => entry.workspacePath), [
+    'Default/hero.glb',
+    'Exports/adventure/hero-rigged.glb',
+  ])
+
+  const root = result.entries[0]
+  const derived = result.entries[1]
+  assert.equal(root.sourceScope, 'generated')
+  assert.equal(root.displayName, 'Hero')
+  assert.equal(derived.displayName, 'Hero Rigged')
+  assert.equal(derived.capability, 'rigged-mesh')
+  assert.equal(derived.createdAt, '2026-06-16T10:00:00.000Z')
+  assert.equal(derived.semantic?.project, 'Adventure')
+  assert.deepEqual(derived.semantic?.tags, ['rigged', 'animated', 'clip-hero-walk', 'mid-poly'])
+  assert.equal(derived.semantic?.derivedFrom?.parent.workspacePath, 'Default/hero.glb')
+  assert.equal(derived.semantic?.derivedFrom?.root.workspacePath, 'Default/hero.glb')
+}))
+
 test('reads and opens only safe GLB/GLTF workspace assets', () => withWorkspace(async (workspaceDir) => {
   await mkdir(path.join(workspaceDir, 'Workflows/checkpoints'), { recursive: true })
   await mkdir(path.join(workspaceDir, 'Exports'), { recursive: true })
@@ -198,6 +243,116 @@ test('fails closed for unsafe, self, missing, and mismatched sourceWorkspacePath
   assert.equal(!mismatched.success && mismatched.error.code, 'not-openable')
 }))
 
+test('reads a sibling .thumb.png for GLB assets and stays silent when one is missing', () => withWorkspace(async (workspaceDir) => {
+  await mkdir(path.join(workspaceDir, 'Exports/props'), { recursive: true })
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.glb'), 'glb')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.thumb.png'), 'fake-png-bytes')
+  await writeFile(path.join(workspaceDir, 'Exports/props/no-thumb.glb'), 'glb')
+  await writeFile(path.join(workspaceDir, 'Exports/static.ply'), 'ply')
+
+  const withThumb = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/hero.glb' })
+  assert.equal(withThumb.success, true)
+  assert.equal(withThumb.success && withThumb.dataUrl, `data:image/png;base64,${Buffer.from('fake-png-bytes').toString('base64')}`)
+
+  const withoutThumb = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/no-thumb.glb' })
+  assert.equal(withoutThumb.success, false)
+
+  const nonMesh = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/static.ply' })
+  assert.equal(nonMesh.success, false)
+
+  const unsafe = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: '../secret.glb' })
+  assert.equal(unsafe.success, false)
+}))
+
+test('attaches preview clip metadata to the thumbnail response when a manifest exists', () => withWorkspace(async (workspaceDir) => {
+  await mkdir(path.join(workspaceDir, 'Exports/props'), { recursive: true })
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.glb'), 'glb')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.thumb.png'), 'fake-png-bytes')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.preview-idle.webp'), 'fake-idle-webp')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.preview-walk.webp'), 'fake-walk-webp')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.previews.json'), JSON.stringify([
+    { clip: 'idle', file: 'hero.preview-idle.webp', duration: 1.5 },
+    { clip: 'walk', file: 'hero.preview-walk.webp', duration: 0.8 },
+  ]))
+
+  const withThumb = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/hero.glb' })
+  assert.equal(withThumb.success, true)
+  assert.deepEqual(withThumb.success && withThumb.previews, [
+    { clip: 'idle', duration: 1.5 },
+    { clip: 'walk', duration: 0.8 },
+  ])
+}))
+
+test('fetches a specific preview clip WebP by name over the same thumbnail request', () => withWorkspace(async (workspaceDir) => {
+  await mkdir(path.join(workspaceDir, 'Exports/props'), { recursive: true })
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.glb'), 'glb')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.preview-walk.webp'), 'fake-walk-webp')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.previews.json'), JSON.stringify([
+    { clip: 'walk', file: 'hero.preview-walk.webp', duration: 0.8 },
+  ]))
+
+  const clip = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/hero.glb', previewClip: 'walk' })
+  assert.equal(clip.success, true)
+  assert.equal(clip.success && clip.dataUrl, `data:image/webp;base64,${Buffer.from('fake-walk-webp').toString('base64')}`)
+
+  const unknownClip = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/hero.glb', previewClip: 'sprint' })
+  assert.equal(unknownClip.success, false)
+}))
+
+test('thumbnail response carries no previews field when no manifest exists, and stays silent on a malformed one', () => withWorkspace(async (workspaceDir) => {
+  await mkdir(path.join(workspaceDir, 'Exports/props'), { recursive: true })
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.glb'), 'glb')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.thumb.png'), 'fake-png-bytes')
+  await writeFile(path.join(workspaceDir, 'Exports/props/broken.glb'), 'glb')
+  await writeFile(path.join(workspaceDir, 'Exports/props/broken.thumb.png'), 'fake-png-bytes')
+  await writeFile(path.join(workspaceDir, 'Exports/props/broken.previews.json'), 'not valid json{')
+
+  const noManifest = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/hero.glb' })
+  assert.equal(noManifest.success, true)
+  assert.equal(noManifest.success && noManifest.previews, undefined)
+
+  const malformedManifest = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/broken.glb' })
+  assert.equal(malformedManifest.success, true)
+  assert.equal(malformedManifest.success && malformedManifest.previews, undefined)
+}))
+
+test('rejects a preview manifest entry that tries to escape the asset directory via its file field', () => withWorkspace(async (workspaceDir) => {
+  await mkdir(path.join(workspaceDir, 'Exports/props'), { recursive: true })
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.glb'), 'glb')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.thumb.png'), 'fake-png-bytes')
+  await writeFile(path.join(workspaceDir, 'secret.webp'), 'top-secret-bytes')
+  await writeFile(path.join(workspaceDir, 'Exports/props/hero.previews.json'), JSON.stringify([
+    { clip: 'escape-relative', file: '../../secret.webp', duration: 1 },
+    { clip: 'escape-absolute', file: '/etc/passwd', duration: 1 },
+    { clip: 'wrong-extension', file: 'hero.glb', duration: 1 },
+  ]))
+
+  // The manifest lists the clip in its metadata (harmless — it's just a name),
+  // but every attempt to actually fetch the referenced file must fail closed.
+  const listed = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/hero.glb' })
+  assert.equal(listed.success, true)
+  assert.equal(listed.success && listed.previews?.length, 3)
+
+  const relative = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/hero.glb', previewClip: 'escape-relative' })
+  assert.equal(relative.success, false)
+  const absolute = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/hero.glb', previewClip: 'escape-absolute' })
+  assert.equal(absolute.success, false)
+  const wrongExtension = await readWorkspaceAssetLibraryThumbnail({ workspaceDir, workspacePath: 'Exports/props/hero.glb', previewClip: 'wrong-extension' })
+  assert.equal(wrongExtension.success, false)
+}))
+
+test('IPC thumbnail handler forwards previewClip from payload', async () => {
+  const handlers = new Map<string, (event: unknown, payload: unknown) => Promise<unknown>>()
+  registerWorkspaceAssetLibraryIpcHandlers({
+    ipcMain: { handle: (channel, handler) => handlers.set(channel, handler) },
+    getWorkspaceDir: () => '/tmp/modly-workspace',
+  })
+
+  const result = await handlers.get('workspace:library:thumbnail')?.({}, { workspacePath: 'Exports/hero.glb', previewClip: 'walk' })
+  // No such workspace/file in this test, so it must fail closed rather than throw.
+  assert.equal((result as { success: boolean }).success, false)
+})
+
 test('IPC read and open handlers forward sourceWorkspacePath without trusting malformed payloads', async () => {
   const handlers = new Map<string, (event: unknown, payload: unknown) => Promise<unknown>>()
   registerWorkspaceAssetLibraryIpcHandlers({
@@ -224,7 +379,12 @@ test('registers workspace library IPC handlers with structured results', async (
   assert.equal(typeof handlers.get('workspace:library:list'), 'function')
   assert.equal(typeof handlers.get('workspace:library:read'), 'function')
   assert.equal(typeof handlers.get('workspace:library:open'), 'function')
+  assert.equal(typeof handlers.get('workspace:library:thumbnail'), 'function')
   const result = await handlers.get('workspace:library:read')?.({}, { workspacePath: '../escape.glb' })
   assert.equal(typeof (result as { success?: unknown }).success, 'boolean')
   assert.equal((result as { success: boolean, error?: { code: string } }).error?.code, 'unsafe-path')
+  const thumbnail = await handlers.get('workspace:library:thumbnail')?.({}, { workspacePath: '../escape.glb' })
+  assert.equal((thumbnail as { success: boolean }).success, false)
+  const missingPayload = await handlers.get('workspace:library:thumbnail')?.({}, {})
+  assert.equal((missingPayload as { success: boolean }).success, false)
 })
diff --git a/electron/main/artifact-registry-service.ts b/electron/main/artifact-registry-service.ts
index 3c26de73..2d4d9595 100644
--- a/electron/main/artifact-registry-service.ts
+++ b/electron/main/artifact-registry-service.ts
@@ -8,18 +8,22 @@ import type {
   AssetLibraryError,
   AssetLibraryListResult,
   AssetLibraryOpenResult,
+  AssetLibraryPreviewClip,
   AssetLibraryPreviewKind,
   AssetLibraryPreviewPayload,
   AssetLibraryReadResult,
+  AssetLibraryLineageLink,
+  AssetLibrarySemanticMetadata,
   AssetLibrarySourceScope,
+  AssetLibraryThumbnailResult,
 } from '../../src/shared/types/assetLibrary'
 import type { ArtifactProvenance } from '../../src/shared/types/artifacts'
 
 const WINDOWS_ABSOLUTE_PATH = /^[a-zA-Z]:[\\/]/
 const ENCODED_ESCAPE_PATTERN = /%2e|%2f|%5c/i
-const ALLOWED_ROOTS = ['Workflows', 'Exports'] as const
+const ALLOWED_ROOTS = ['Default', 'Workflows', 'Exports'] as const
 const SKIPPED_DIRS = new Set(['tmp', 'temp', 'cache'])
-const INTERNAL_SUFFIXES = ['.artifact.json', '.rigmeta.json'] as const
+const INTERNAL_SUFFIXES = ['.artifact.json', '.rigmeta.json', '.tags.json', '.previews.json', '.thumb.png'] as const
 const TEXT_EXTENSIONS = new Set(['json', 'txt', 'md'])
 const INTRINSIC_MOTION_EXTENSIONS = new Set(['bvh', 'npz'])
 const MESH_EXTENSIONS = new Set(['glb', 'gltf', 'obj', 'stl', 'ply', 'splat'])
@@ -51,6 +55,11 @@ export interface WorkspaceAssetLibraryReadRequest extends WorkspaceAssetLibraryR
   sourceWorkspacePath?: string
 }
 
+export interface WorkspaceAssetLibraryThumbnailRequest extends WorkspaceAssetLibraryRequest {
+  workspacePath: string
+  previewClip?: string
+}
+
 interface AssetLibraryMetadata {
   sourceWorkspacePath?: string
   manifestWorkspacePath?: string
@@ -60,6 +69,11 @@ interface AssetLibraryMetadata {
   warnings: string[]
 }
 
+interface AssetLibrarySemanticRead {
+  semantic?: AssetLibrarySemanticMetadata
+  warnings: string[]
+}
+
 export interface IpcMainLike {
   handle(channel: string, handler: (event: unknown, payload?: unknown) => Promise<unknown>): void
 }
@@ -112,7 +126,9 @@ function isGlbOrGltf(workspacePath: string): boolean {
 }
 
 function sourceScopeFor(workspacePath: string): AssetLibrarySourceScope {
-  return workspacePath.startsWith('Exports/') ? 'exports' : 'workflows'
+  if (workspacePath.startsWith('Exports/')) return 'exports'
+  if (workspacePath.startsWith('Workflows/')) return 'workflows'
+  return 'generated'
 }
 
 export function classifyAssetLibraryCandidate(candidate: AssetLibraryClassificationCandidate): AssetLibraryClassification {
@@ -150,6 +166,11 @@ function objectField(value: unknown): Record<string, unknown> | undefined {
   return typeof value === 'object' && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : undefined
 }
 
+function stringListField(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return [...new Set(value.map(stringField).filter((item): item is string => item !== undefined))]
+}
+
 function manifestCapabilityFor(workspacePath: string): 'generated-world' | 'scene-manifest' | undefined {
   if (workspacePath.endsWith('.world.json')) return 'generated-world'
   if (workspacePath.endsWith('.scene.json')) return 'scene-manifest'
@@ -203,12 +224,87 @@ async function readMetadata(workspaceDir: string, workspacePath: string, absolut
   return metadata
 }
 
+function semanticSidecarPathFor(absolutePath: string): string {
+  return absolutePath.replace(/\.[^./\\]+$/, '') + '.tags.json'
+}
+
+function safeSemanticLineageLink(
+  workspaceDir: string,
+  value: unknown,
+): AssetLibraryLineageLink | undefined {
+  const candidate = objectField(value)
+  const rawPath = stringField(candidate?.path ?? candidate?.workspacePath)
+  if (!rawPath) return undefined
+  try {
+    const { workspacePath } = normalizeWorkspaceAssetPath(workspaceDir, rawPath)
+    return {
+      workspacePath,
+      displayName: stringField(candidate?.name ?? candidate?.displayName),
+    }
+  } catch {
+    return undefined
+  }
+}
+
+async function readSemanticMetadata(
+  workspaceDir: string,
+  absolutePath: string,
+): Promise<AssetLibrarySemanticRead> {
+  let parsed: Record<string, unknown>
+  try {
+    const raw = JSON.parse(await readFile(semanticSidecarPathFor(absolutePath), 'utf8')) as unknown
+    const object = objectField(raw)
+    if (!object) return { warnings: ['Asset metadata sidecar is not a JSON object.'] }
+    parsed = object
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { warnings: [] }
+    return { warnings: ['Asset metadata sidecar could not be read.'] }
+  }
+
+  const warnings: string[] = []
+  const name = stringField(parsed.name)
+  const project = stringField(parsed.project)
+  const tags = stringListField(parsed.tags)
+  if (parsed.tags !== undefined && !Array.isArray(parsed.tags)) {
+    warnings.push('Ignored invalid asset tags.')
+  }
+
+  const createdRaw = stringField(parsed.created)
+  const created = createdRaw && Number.isFinite(Date.parse(createdRaw)) ? createdRaw : undefined
+  if (createdRaw && !created) warnings.push('Ignored invalid asset creation date.')
+
+  let derivedFrom: AssetLibrarySemanticMetadata['derivedFrom']
+  if (parsed.derived_from !== undefined) {
+    const rawDerivedFrom = objectField(parsed.derived_from)
+    const parent = safeSemanticLineageLink(workspaceDir, rawDerivedFrom?.parent)
+    const root = safeSemanticLineageLink(workspaceDir, rawDerivedFrom?.root)
+    if (parent && root) {
+      derivedFrom = { parent, root }
+    } else {
+      warnings.push('Ignored unsafe or invalid asset lineage.')
+    }
+  }
+
+  return {
+    semantic: {
+      ...(name ? { name } : {}),
+      ...(project ? { project } : {}),
+      tags,
+      ...(created ? { created } : {}),
+      ...(derivedFrom ? { derivedFrom } : {}),
+    },
+    warnings,
+  }
+}
+
 function shouldSkipDirectory(name: string): boolean {
   return name.startsWith('.') || SKIPPED_DIRS.has(name.toLowerCase())
 }
 
 function shouldSkipFile(name: string): boolean {
-  return name.startsWith('.') || INTERNAL_SUFFIXES.some((suffix) => name.endsWith(suffix))
+  return name.startsWith('.')
+    || INTERNAL_SUFFIXES.some((suffix) => name.endsWith(suffix))
+    || /\.preview-[^/\\]+\.webp$/i.test(name)
 }
 
 async function hasRigMetadata(absolutePath: string): Promise<boolean> {
@@ -225,13 +321,18 @@ async function hasRigMetadata(absolutePath: string): Promise<boolean> {
 async function buildEntry(workspaceDir: string, workspacePath: string): Promise<AssetLibraryEntry> {
   const { absolutePath } = normalizeWorkspaceAssetPath(workspaceDir, workspacePath)
   const stats = await stat(absolutePath)
-  const classification = classifyAssetLibraryCandidate({ workspacePath, hasRigMetadata: await hasRigMetadata(absolutePath) })
+  const semanticRead = await readSemanticMetadata(workspaceDir, absolutePath)
+  const semanticTags = semanticRead.semantic?.tags ?? []
+  const classification = classifyAssetLibraryCandidate({
+    workspacePath,
+    hasRigMetadata: semanticTags.includes('rigged') || await hasRigMetadata(absolutePath),
+  })
   const metadata = await readMetadata(workspaceDir, workspacePath, absolutePath)
   const manifestCapability = metadata.manifestWorkspacePath ? manifestCapabilityFor(metadata.manifestWorkspacePath) : undefined
   return {
     id: `library:${workspacePath}`,
     workspacePath,
-    displayName: basename(workspacePath),
+    displayName: semanticRead.semantic?.name ?? basename(workspacePath),
     sourceScope: sourceScopeFor(workspacePath),
     capability: classification.capability,
     state: classification.state,
@@ -241,11 +342,12 @@ async function buildEntry(workspaceDir: string, workspacePath: string): Promise<
     artifactId: metadata.artifactId,
     versionId: metadata.versionId,
     provenance: metadata.provenance,
-    warnings: metadata.warnings,
+    warnings: [...metadata.warnings, ...semanticRead.warnings],
     openable: classification.openable,
     nonOpenableReason: classification.nonOpenableReason,
-    createdAt: (stats.birthtime.getTime() > 0 ? stats.birthtime : stats.mtime).toISOString(),
+    createdAt: semanticRead.semantic?.created ?? (stats.birthtime.getTime() > 0 ? stats.birthtime : stats.mtime).toISOString(),
     updatedAt: stats.mtime.toISOString(),
+    semantic: semanticRead.semantic,
   }
 }
 
@@ -342,12 +444,131 @@ export async function openWorkspaceAssetLibraryEntry(request: WorkspaceAssetLibr
   return { success: true, entry: read.entry }
 }
 
-function readPayloadRequest(payload: unknown): { workspacePath?: string, sourceWorkspacePath?: string } {
+function previewManifestAbsolutePathFor(absolutePath: string): string {
+  return absolutePath.replace(/\.(glb|gltf)$/i, '.previews.json')
+}
+
+interface AssetLibraryPreviewManifestEntry {
+  clip: string
+  file: string
+  duration: number
+}
+
+function parsePreviewManifestList(raw: unknown): unknown[] {
+  if (Array.isArray(raw)) return raw
+  if (typeof raw === 'object' && raw !== null) {
+    const container = raw as Record<string, unknown>
+    if (Array.isArray(container.previews)) return container.previews
+    if (Array.isArray(container.clips)) return container.clips
+  }
+  return []
+}
+
+function parsePreviewManifestEntry(raw: unknown): AssetLibraryPreviewManifestEntry | null {
+  if (typeof raw !== 'object' || raw === null) return null
+  const candidate = raw as Record<string, unknown>
+  const clip = stringField(candidate.clip)
+  const file = stringField(candidate.file)
+  const duration = typeof candidate.duration === 'number' && Number.isFinite(candidate.duration) ? candidate.duration : undefined
+  if (!clip || !file || duration === undefined) return null
+  return { clip, file, duration }
+}
+
+// The preview manifest and its clips are generated by a separate pipeline (not
+// thumbs.py) and may not exist yet, or may be malformed mid-write — both are
+// normal, silent conditions handled the same way a missing thumbnail is.
+async function readPreviewManifestEntries(absolutePath: string): Promise<AssetLibraryPreviewManifestEntry[]> {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(await readFile(previewManifestAbsolutePathFor(absolutePath), 'utf8'))
+  } catch {
+    return []
+  }
+  return parsePreviewManifestList(parsed)
+    .map(parsePreviewManifestEntry)
+    .filter((entry): entry is AssetLibraryPreviewManifestEntry => entry !== null)
+}
+
+async function readAssetLibraryPreviewClips(absolutePath: string): Promise<AssetLibraryPreviewClip[]> {
+  const entries = await readPreviewManifestEntries(absolutePath)
+  return entries.map(({ clip, duration }) => ({ clip, duration }))
+}
+
+/**
+ * Resolves a manifest-listed clip name to a safe absolute WebP path. The
+ * manifest's `file` is trusted only as a filename — any directory component is
+ * discarded via `basename` — and the reconstructed sibling workspace path is
+ * re-validated through the same `normalizeWorkspaceAssetPath` guard every
+ * other workspace library read uses, so a stale or malformed manifest can
+ * never point outside the asset's own directory.
+ */
+async function resolvePreviewClipAbsolutePath(
+  workspaceDir: string,
+  workspacePath: string,
+  absolutePath: string,
+  previewClip: string,
+): Promise<string | null> {
+  const entries = await readPreviewManifestEntries(absolutePath)
+  const match = entries.find((entry) => entry.clip === previewClip)
+  if (!match) return null
+  const fileName = basename(match.file)
+  if (extensionOf(fileName) !== 'webp') return null
+  const siblingWorkspacePath = [...workspacePath.split('/').slice(0, -1), fileName].join('/')
+  let normalized: NormalizedWorkspaceAssetPath
+  try {
+    normalized = normalizeWorkspaceAssetPath(workspaceDir, siblingWorkspacePath)
+  } catch {
+    return null
+  }
+  try {
+    await stat(normalized.absolutePath)
+  } catch {
+    return null
+  }
+  return normalized.absolutePath
+}
+
+// Thumbnails are pre-rendered beside their source mesh (see thumbs.py): a
+// `<name>.glb` asset may have a sibling `<name>.thumb.png`. Missing files are
+// a normal, silent condition, never surfaced as an AssetLibraryError.
+//
+// The same request also serves looping preview clips generated by a separate
+// pipeline as `<name>.preview-<clip>.webp`, listed in a sibling
+// `<name>.previews.json` manifest. Passing `previewClip` fetches that clip's
+// WebP instead of the static thumbnail; omitting it fetches the static
+// thumbnail as before and, when a manifest exists, attaches the clip list so
+// the UI can offer hover-to-animate without a second round trip to discover
+// it. No manifest yet (the common case until the preview pipeline lands) is
+// indistinguishable from today's behavior.
+export async function readWorkspaceAssetLibraryThumbnail(request: WorkspaceAssetLibraryThumbnailRequest): Promise<AssetLibraryThumbnailResult> {
+  try {
+    const normalized = normalizeWorkspaceAssetPath(request.workspaceDir, request.workspacePath)
+    if (!isGlbOrGltf(normalized.workspacePath)) return { success: false }
+
+    if (request.previewClip) {
+      const clipAbsolutePath = await resolvePreviewClipAbsolutePath(request.workspaceDir, normalized.workspacePath, normalized.absolutePath, request.previewClip)
+      if (!clipAbsolutePath) return { success: false }
+      const buffer = await readFile(clipAbsolutePath)
+      return { success: true, dataUrl: `data:image/webp;base64,${buffer.toString('base64')}` }
+    }
+
+    const thumbnailAbsolutePath = normalized.absolutePath.replace(/\.(glb|gltf)$/i, '.thumb.png')
+    const buffer = await readFile(thumbnailAbsolutePath)
+    const dataUrl = `data:image/png;base64,${buffer.toString('base64')}`
+    const previews = await readAssetLibraryPreviewClips(normalized.absolutePath)
+    return previews.length > 0 ? { success: true, dataUrl, previews } : { success: true, dataUrl }
+  } catch {
+    return { success: false }
+  }
+}
+
+function readPayloadRequest(payload: unknown): { workspacePath?: string, sourceWorkspacePath?: string, previewClip?: string } {
   if (typeof payload !== 'object' || payload === null) return {}
-  const values = payload as { workspacePath?: unknown, sourceWorkspacePath?: unknown }
+  const values = payload as { workspacePath?: unknown, sourceWorkspacePath?: unknown, previewClip?: unknown }
   return {
     workspacePath: typeof values.workspacePath === 'string' ? values.workspacePath : undefined,
     sourceWorkspacePath: typeof values.sourceWorkspacePath === 'string' ? values.sourceWorkspacePath : undefined,
+    previewClip: typeof values.previewClip === 'string' ? values.previewClip : undefined,
   }
 }
 
@@ -363,4 +584,9 @@ export function registerWorkspaceAssetLibraryIpcHandlers(deps: WorkspaceAssetLib
     if (!workspacePath) return { success: false, error: libraryError('invalid-request', 'workspacePath is required.') }
     return openWorkspaceAssetLibraryEntry({ workspaceDir: deps.getWorkspaceDir(), workspacePath, sourceWorkspacePath })
   })
+  deps.ipcMain.handle('workspace:library:thumbnail', async (_event, payload) => {
+    const { workspacePath, previewClip } = readPayloadRequest(payload)
+    if (!workspacePath) return { success: false }
+    return readWorkspaceAssetLibraryThumbnail({ workspaceDir: deps.getWorkspaceDir(), workspacePath, previewClip })
+  })
 }
diff --git a/electron/main/index.ts b/electron/main/index.ts
index 8cf9c810..226713c4 100644
--- a/electron/main/index.ts
+++ b/electron/main/index.ts
@@ -16,6 +16,15 @@ let pythonBridge: PythonBridge | null = null
 process.stdout?.on('error', () => {})
 process.stderr?.on('error', () => {})
 
+// UI zoom: Ctrl/Cmd with + / - / 0 scales the whole window like a browser.
+// Chromium claims those chords before the page can see them, so they are caught
+// here — but the SIZE is not stored here. It lives in the renderer's saved
+// settings, and this only forwards the direction.
+//
+// It used to be stored in both places. The main process restored the saved zoom
+// on load, then the renderer mounted and overwrote it with its own separate
+// "interface scale" setting, so the size was silently lost on every restart.
+
 function createWindow(): void {
   mainWindow = new BrowserWindow({
     width: 1280,
@@ -57,6 +66,23 @@ function createWindow(): void {
       event.preventDefault()
       app.quit()
     }
+
+    const isZoomChord = input.type === 'keyDown' && (input.control || input.meta) && !input.alt
+    if (!isZoomChord) return
+
+    const wc = mainWindow?.webContents
+    if (!wc) return
+
+    if (input.key === '+' || input.key === '=') {
+      event.preventDefault()
+      wc.send('ui:zoomStep', 1)
+    } else if (input.key === '-' || input.key === '_') {
+      event.preventDefault()
+      wc.send('ui:zoomStep', -1)
+    } else if (input.key === '0') {
+      event.preventDefault()
+      wc.send('ui:zoomStep', 0)
+    }
   })
 
   mainWindow.webContents.setWindowOpenHandler((details) => {
diff --git a/electron/main/ipc-handlers.ts b/electron/main/ipc-handlers.ts
index 14fc984a..6a99e269 100644
--- a/electron/main/ipc-handlers.ts
+++ b/electron/main/ipc-handlers.ts
@@ -35,6 +35,8 @@ import {
 import { validateInstallManifest } from './extension-install-utils'
 import { registerWorkspaceAssetLibraryIpcHandlers } from './artifact-registry-service'
 import { updatesSupported } from './updater'
+import { TextureWatchService } from './texture-watch-service'
+import type { TextureWatchChoice } from '../../src/shared/types/liveTexture'
 
 type WindowGetter = () => BrowserWindow | null
 const pExecFile = promisify(execFile)
@@ -276,6 +278,10 @@ const renameWithRetry = (from: string, to: string, label: string): Promise<FsRet
 const activeExtensionInstalls = new Set<string>()
 
 export function setupIpcHandlers(pythonBridge: PythonBridge, getWindow: WindowGetter): void {
+  const textureWatchService = new TextureWatchService()
+  const textureWatchOwners = new Set<number>()
+  app.once('before-quit', () => textureWatchService.stopAll())
+
   // Reconcile leftovers of interrupted installs. No install can be in flight
   // this early in the app's life, so anything matching is stale:
   //  - staging dirs → discard (never the only copy of anything)
@@ -426,6 +432,36 @@ export function setupIpcHandlers(pythonBridge: PythonBridge, getWindow: WindowGe
     return result.canceled ? null : result.filePaths[0]
   })
 
+  ipcMain.handle('texture:chooseAndWatch', async (event): Promise<TextureWatchChoice> => {
+    const win = getWindow()
+    if (!win) return { cancelled: true }
+
+    const result = await dialog.showOpenDialog(win, {
+      title: 'Choose a texture to watch',
+      filters: [{ name: 'PNG image', extensions: ['png'] }],
+      properties: ['openFile'],
+    })
+    if (result.canceled || !result.filePaths[0]) return { cancelled: true }
+
+    const ownerId = event.sender.id
+    if (!textureWatchOwners.has(ownerId)) {
+      textureWatchOwners.add(ownerId)
+      event.sender.once('destroyed', () => {
+        textureWatchOwners.delete(ownerId)
+        textureWatchService.stop(ownerId)
+      })
+    }
+
+    const update = await textureWatchService.start(ownerId, result.filePaths[0], (next) => {
+      if (!event.sender.isDestroyed()) event.sender.send('texture:changed', next)
+    })
+    return { cancelled: false, update }
+  })
+
+  ipcMain.handle('texture:stopWatching', (event) => {
+    textureWatchService.stop(event.sender.id)
+  })
+
   ipcMain.handle('fs:selectMeshFile', async () => {
     const win = getWindow()
     if (!win) return null
@@ -1395,7 +1431,7 @@ export function setupIpcHandlers(pythonBridge: PythonBridge, getWindow: WindowGe
   })
 
   // Run a process extension in an isolated worker thread
-  ipcMain.handle('extensions:runProcess', async (_, extensionId: string, input: { filePath?: string; text?: string; texts?: (string | undefined)[]; nodeId?: string }, params: Record<string, unknown>) => {
+  ipcMain.handle('extensions:runProcess', async (_, extensionId: string, input: { filePath?: string; text?: string; texts?: (string | undefined)[]; nodeId?: string; sourceAssetPath?: string }, params: Record<string, unknown>) => {
     const userData        = app.getPath('userData')
     const { extensionsDir, workspaceDir } = getSettings(userData)
 
diff --git a/electron/main/process-runner.ts b/electron/main/process-runner.ts
index b31a62e4..c0f08223 100644
--- a/electron/main/process-runner.ts
+++ b/electron/main/process-runner.ts
@@ -52,6 +52,9 @@ export interface ProcessInput {
   /** Per-slot texts for multi-text-input nodes (index = target handle slot). */
   texts?:    (string | undefined)[]
   nodeId?:   string
+  /** Absolute path of the existing workspace asset this input was sourced from
+   *  (if any) — threaded through the run so mesh-exporter can record lineage. */
+  sourceAssetPath?: string
 }
 
 export interface ProcessResult {
diff --git a/electron/main/texture-watch-service.test.ts b/electron/main/texture-watch-service.test.ts
new file mode 100644
index 00000000..6f8d42e7
--- /dev/null
+++ b/electron/main/texture-watch-service.test.ts
@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+
+import type { TextureWatchUpdate } from '../../src/shared/types/liveTexture.ts'
+import { readPngInfo, TextureWatchService } from './texture-watch-service.ts'
+
+const ONE_PIXEL_PNG = Buffer.from(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
+  'base64',
+)
+
+async function waitFor(
+  updates: TextureWatchUpdate[],
+  predicate: (update: TextureWatchUpdate) => boolean,
+  timeoutMs = 3_000,
+): Promise<TextureWatchUpdate> {
+  const started = Date.now()
+  while (Date.now() - started < timeoutMs) {
+    const match = updates.find(predicate)
+    if (match) return match
+    await new Promise((resolve) => setTimeout(resolve, 20))
+  }
+  throw new Error(`Timed out waiting for texture update. Saw: ${JSON.stringify(updates)}`)
+}
+
+test('reads PNG dimensions and rejects a partial save', () => {
+  assert.deepEqual(readPngInfo(ONE_PIXEL_PNG), { width: 1, height: 1 })
+  assert.throws(
+    () => readPngInfo(ONE_PIXEL_PNG.subarray(0, 24)),
+    /invalid PNG header|incomplete PNG file/,
+  )
+})
+
+test('reports a malformed save, keeps watching, and recovers on the next valid save', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'modly-texture-watch-'))
+  const filePath = join(dir, 'paint.png')
+  const updates: TextureWatchUpdate[] = []
+  const service = new TextureWatchService()
+
+  try {
+    await writeFile(filePath, ONE_PIXEL_PNG)
+    const initial = await service.start(7, filePath, (update) => updates.push(update))
+    assert.equal(initial.state, 'ready')
+    assert.equal(initial.width, 1)
+    assert.equal(initial.height, 1)
+
+    await writeFile(filePath, Buffer.from('not an image'))
+    await waitFor(updates, (update) => update.state === 'reading')
+    const failed = await waitFor(updates, (update) => update.state === 'error')
+    assert.match(failed.message ?? '', /could not be read/)
+
+    await writeFile(filePath, ONE_PIXEL_PNG)
+    const recovered = await waitFor(
+      updates,
+      (update) => update.state === 'ready' && update.revision > failed.revision,
+    )
+    assert.equal(recovered.width, 1)
+    assert.equal(recovered.height, 1)
+    assert.match(recovered.dataUrl ?? '', /^data:image\/png;base64,/)
+  } finally {
+    service.stopAll()
+    await rm(dir, { recursive: true, force: true })
+  }
+})
diff --git a/electron/main/texture-watch-service.ts b/electron/main/texture-watch-service.ts
new file mode 100644
index 00000000..77d0af73
--- /dev/null
+++ b/electron/main/texture-watch-service.ts
@@ -0,0 +1,172 @@
+import { watch as watchDirectory, type FSWatcher } from 'node:fs'
+import { readFile, stat } from 'node:fs/promises'
+import { basename, dirname, extname } from 'node:path'
+
+import type { TextureWatchUpdate } from '../../src/shared/types/liveTexture'
+
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])
+const PNG_END = Buffer.from([0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130])
+const SAVE_SETTLE_MS = 60
+const RETRY_MS = 120
+const MAX_READ_ATTEMPTS = 6
+
+interface WatchedTexture {
+  ownerId: number
+  filePath: string
+  fileName: string
+  revision: number
+  watcher: FSWatcher
+  timer: ReturnType<typeof setTimeout> | null
+  send: (update: TextureWatchUpdate) => void
+}
+
+export interface PngInfo {
+  width: number
+  height: number
+}
+
+export function readPngInfo(buffer: Buffer): PngInfo {
+  if (
+    buffer.length < 33
+    || !buffer.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)
+    || buffer.toString('ascii', 12, 16) !== 'IHDR'
+    || buffer.readUInt32BE(8) !== 13
+  ) {
+    throw new Error('invalid PNG header')
+  }
+
+  const width = buffer.readUInt32BE(16)
+  const height = buffer.readUInt32BE(20)
+  if (width < 1 || height < 1 || !buffer.subarray(-PNG_END.length).equals(PNG_END)) {
+    throw new Error('incomplete PNG file')
+  }
+
+  return { width, height }
+}
+
+export class TextureWatchService {
+  private sessions = new Map<number, WatchedTexture>()
+
+  async start(
+    ownerId: number,
+    filePath: string,
+    send: (update: TextureWatchUpdate) => void,
+  ): Promise<TextureWatchUpdate> {
+    if (extname(filePath).toLowerCase() !== '.png') {
+      throw new Error('Live texture updates currently support PNG files.')
+    }
+
+    this.stop(ownerId)
+
+    const fileName = basename(filePath)
+    const session: WatchedTexture = {
+      ownerId,
+      filePath,
+      fileName,
+      revision: 0,
+      watcher: watchDirectory(dirname(filePath), (_eventType, changedName) => {
+        if (changedName && changedName.toString() !== fileName) return
+        this.queueRead(session)
+      }),
+      timer: null,
+      send,
+    }
+    session.watcher.on('error', () => {
+      if (this.sessions.get(ownerId) !== session) return
+      const revision = ++session.revision
+      send({
+        state: 'error',
+        filePath,
+        fileName,
+        revision,
+        changedAt: Date.now(),
+        message: 'Texture watching stopped because the file could not be watched. Choose it again to retry.',
+      })
+      this.stop(ownerId)
+    })
+    this.sessions.set(ownerId, session)
+
+    const revision = ++session.revision
+    return this.readUpdate(session, revision)
+  }
+
+  stop(ownerId: number): void {
+    const session = this.sessions.get(ownerId)
+    if (!session) return
+    this.sessions.delete(ownerId)
+    if (session.timer) clearTimeout(session.timer)
+    session.watcher.close()
+  }
+
+  stopAll(): void {
+    for (const ownerId of [...this.sessions.keys()]) this.stop(ownerId)
+  }
+
+  private queueRead(session: WatchedTexture): void {
+    if (this.sessions.get(session.ownerId) !== session) return
+    const revision = ++session.revision
+    if (session.timer) clearTimeout(session.timer)
+    session.send({
+      state: 'reading',
+      filePath: session.filePath,
+      fileName: session.fileName,
+      revision,
+      changedAt: Date.now(),
+      message: 'Checking the saved texture…',
+    })
+    session.timer = setTimeout(() => {
+      session.timer = null
+      void this.publishAfterSave(session, revision, 0)
+    }, SAVE_SETTLE_MS)
+  }
+
+  private async publishAfterSave(
+    session: WatchedTexture,
+    revision: number,
+    attempt: number,
+  ): Promise<void> {
+    if (this.sessions.get(session.ownerId) !== session || session.revision !== revision) return
+
+    const update = await this.readUpdate(session, revision)
+    if (this.sessions.get(session.ownerId) !== session || session.revision !== revision) return
+    session.send(update)
+
+    if (update.state === 'error' && attempt + 1 < MAX_READ_ATTEMPTS) {
+      session.timer = setTimeout(() => {
+        session.timer = null
+        void this.publishAfterSave(session, revision, attempt + 1)
+      }, RETRY_MS)
+    }
+  }
+
+  private async readUpdate(session: WatchedTexture, revision: number): Promise<TextureWatchUpdate> {
+    const changedAt = Date.now()
+    try {
+      const [buffer, fileStat] = await Promise.all([
+        readFile(session.filePath),
+        stat(session.filePath),
+      ])
+      const { width, height } = readPngInfo(buffer)
+      return {
+        state: 'ready',
+        filePath: session.filePath,
+        fileName: session.fileName,
+        revision,
+        changedAt,
+        savedAt: fileStat.mtimeMs,
+        width,
+        height,
+        dataUrl: `data:image/png;base64,${buffer.toString('base64')}`,
+      }
+    } catch {
+      return {
+        state: 'error',
+        filePath: session.filePath,
+        fileName: session.fileName,
+        revision,
+        changedAt,
+        message: 'The saved texture could not be read. It may still be saving or the file may be damaged.',
+      }
+    }
+  }
+}
diff --git a/electron/preload/artifact-registry-preload.test.ts b/electron/preload/artifact-registry-preload.test.ts
index 511589e4..5f0f66c4 100644
--- a/electron/preload/artifact-registry-preload.test.ts
+++ b/electron/preload/artifact-registry-preload.test.ts
@@ -24,6 +24,8 @@ test('preload exposes scoped workspace library list/read/open methods', async ()
     workspacePath: 'Workflows/checkpoints/hero.landmarks.v1.json',
     sourceWorkspacePath: 'Workflows/checkpoints/hero.glb',
   })
+  await api.workspace.library.thumbnail({ workspacePath: 'Exports/hero.glb' })
+  await api.workspace.library.thumbnail({ workspacePath: 'Exports/hero.glb', previewClip: 'walk' })
 
   assert.deepEqual(calls, [
     { channel: 'workspace:library:list', payload: undefined },
@@ -41,5 +43,7 @@ test('preload exposes scoped workspace library list/read/open methods', async ()
         sourceWorkspacePath: 'Workflows/checkpoints/hero.glb',
       },
     },
+    { channel: 'workspace:library:thumbnail', payload: { workspacePath: 'Exports/hero.glb' } },
+    { channel: 'workspace:library:thumbnail', payload: { workspacePath: 'Exports/hero.glb', previewClip: 'walk' } },
   ])
 })
diff --git a/electron/preload/electron-api.ts b/electron/preload/electron-api.ts
index 4f351b49..d2c89f9b 100644
--- a/electron/preload/electron-api.ts
+++ b/electron/preload/electron-api.ts
@@ -4,7 +4,10 @@ import type {
   AssetLibraryOpenResult,
   AssetLibraryReadRequest,
   AssetLibraryReadResult,
+  AssetLibraryThumbnailRequest,
+  AssetLibraryThumbnailResult,
 } from '../../src/shared/types/assetLibrary'
+import type { TextureWatchChoice, TextureWatchUpdate } from '../../src/shared/types/liveTexture'
 
 export interface IpcRendererLike {
   invoke(channel: string, ...args: unknown[]): Promise<unknown>
@@ -32,7 +35,16 @@ export function createElectronApi(ipcRenderer: IpcRendererLike, webFrame: WebFra
     },
 
     // Renderer UI (zoom whole page — scales every px/rem consistently)
-    ui: { setZoomFactor: (factor: number) => webFrame.setZoomFactor(factor) },
+    ui: {
+      setZoomFactor: (factor: number) => webFrame.setZoomFactor(factor),
+      // Chromium eats Ctrl/Cmd +/- before the page sees them, so the main
+      // process catches the chord and forwards only the direction. The size
+      // itself is the renderer's, so there is exactly one copy of it.
+      onZoomStep: (cb: (step: number) => void) => {
+        ipcRenderer.on('ui:zoomStep', (_event, step) => cb(step as number))
+      },
+      offZoomStep: () => ipcRenderer.removeAllListeners('ui:zoomStep'),
+    },
 
     // Shell utilities
     shell: { openExternal: (url: string) => ipcRenderer.invoke('shell:openExternal', url) },
@@ -87,6 +99,17 @@ export function createElectronApi(ipcRenderer: IpcRendererLike, webFrame: WebFra
         ipcRenderer.invoke('fs:readScreenshotDataUrl', filename) as Promise<string>,
     },
 
+    texture: {
+      chooseAndWatch: (): Promise<TextureWatchChoice> =>
+        ipcRenderer.invoke('texture:chooseAndWatch') as Promise<TextureWatchChoice>,
+      stopWatching: (): Promise<void> =>
+        ipcRenderer.invoke('texture:stopWatching') as Promise<void>,
+      onChange: (cb: (update: TextureWatchUpdate) => void) => {
+        ipcRenderer.on('texture:changed', (_event, update) => cb(update as TextureWatchUpdate))
+      },
+      offChange: () => ipcRenderer.removeAllListeners('texture:changed'),
+    },
+
     // Settings
     settings: {
       get: (): Promise<{ modelsDir: string; workspaceDir: string; workflowsDir: string; extensionsDir: string; hfToken?: string }> =>
@@ -189,6 +212,7 @@ export function createElectronApi(ipcRenderer: IpcRendererLike, webFrame: WebFra
         list: (): Promise<AssetLibraryListResult> => ipcRenderer.invoke('workspace:library:list') as Promise<AssetLibraryListResult>,
         read: (request: AssetLibraryReadRequest): Promise<AssetLibraryReadResult> => ipcRenderer.invoke('workspace:library:read', request) as Promise<AssetLibraryReadResult>,
         open: (request: AssetLibraryOpenRequest): Promise<AssetLibraryOpenResult> => ipcRenderer.invoke('workspace:library:open', request) as Promise<AssetLibraryOpenResult>,
+        thumbnail: (request: AssetLibraryThumbnailRequest): Promise<AssetLibraryThumbnailResult> => ipcRenderer.invoke('workspace:library:thumbnail', request) as Promise<AssetLibraryThumbnailResult>,
       },
     },
 
@@ -230,7 +254,7 @@ export function createElectronApi(ipcRenderer: IpcRendererLike, webFrame: WebFra
 
       runProcess: (
         extensionId: string,
-        input:       { filePath?: string; text?: string; texts?: (string | undefined)[]; nodeId?: string },
+        input:       { filePath?: string; text?: string; texts?: (string | undefined)[]; nodeId?: string; sourceAssetPath?: string },
         params:      Record<string, unknown>,
       ): Promise<{ success: boolean; result?: { filePath?: string; text?: string }; error?: string }> =>
         ipcRenderer.invoke('extensions:runProcess', extensionId, input, params) as Promise<{ success: boolean; result?: { filePath?: string; text?: string }; error?: string }>,
diff --git a/electron/preload/texture-watch-preload.test.ts b/electron/preload/texture-watch-preload.test.ts
new file mode 100644
index 00000000..c417168f
--- /dev/null
+++ b/electron/preload/texture-watch-preload.test.ts
@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import type { TextureWatchUpdate } from '../../src/shared/types/liveTexture.ts'
+import { createElectronApi } from './electron-api.ts'
+
+test('preload exposes texture watching without exposing file system internals', async () => {
+  const invokes: string[] = []
+  const listeners = new Map<string, (...args: unknown[]) => void>()
+  const api = createElectronApi({
+    invoke: async (channel: string) => {
+      invokes.push(channel)
+      return channel === 'texture:chooseAndWatch'
+        ? { cancelled: true }
+        : undefined
+    },
+    send: () => undefined,
+    on: (channel, listener) => listeners.set(channel, listener),
+    removeAllListeners: (channel) => listeners.delete(channel),
+  }, { setZoomFactor: () => undefined })
+
+  await api.texture.chooseAndWatch()
+  await api.texture.stopWatching()
+  assert.deepEqual(invokes, ['texture:chooseAndWatch', 'texture:stopWatching'])
+
+  let received: TextureWatchUpdate | null = null
+  api.texture.onChange((update) => { received = update })
+  listeners.get('texture:changed')?.({}, {
+    state: 'reading',
+    filePath: '/tmp/paint.png',
+    fileName: 'paint.png',
+    revision: 2,
+    changedAt: 1,
+  })
+  assert.equal(received?.state, 'reading')
+
+  api.texture.offChange()
+  assert.equal(listeners.has('texture:changed'), false)
+})
diff --git a/package-lock.json b/package-lock.json
index 1f336a2b..944bd257 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "modly",
-  "version": "0.3.5",
+  "version": "0.4.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "modly",
-      "version": "0.3.5",
+      "version": "0.4.1",
       "dependencies": {
         "@electron-toolkit/utils": "^4.0.0",
         "@mkkellogg/gaussian-splats-3d": "^0.4.7",
@@ -25,6 +25,7 @@
         "zustand": "^5.0.3"
       },
       "devDependencies": {
+        "@eslint/js": "^9.39.4",
         "@types/node": "^22.10.1",
         "@types/react": "^18.3.17",
         "@types/react-dom": "^18.3.5",
@@ -37,9 +38,12 @@
         "electron-builder": "^24.13.3",
         "electron-vite": "^2.3.0",
         "eslint": "^9.17.0",
+        "eslint-plugin-react-hooks": "^7.1.1",
+        "globals": "^17.6.0",
         "postcss": "^8.4.49",
         "tailwindcss": "^3.4.17",
         "typescript": "^5.7.2",
+        "typescript-eslint": "^8.61.1",
         "vite": "^5.4.0"
       }
     },
@@ -1193,6 +1197,19 @@
         "concat-map": "0.0.1"
       }
     },
+    "node_modules/@eslint/eslintrc/node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/@eslint/eslintrc/node_modules/minimatch": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.3.tgz",
@@ -1206,10 +1223,11 @@
       }
     },
     "node_modules/@eslint/js": {
-      "version": "9.39.3",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.3.tgz",
-      "integrity": "sha512-1B1VkCq6FuUNlQvlBYb+1jDu/gV297TIs/OeiaSR9l1H27SVW55ONE1e1Vp16NqP683+xEGzxYtv4XCiDPaQiw==",
+      "version": "9.39.5",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.5.tgz",
+      "integrity": "sha512-QywQuszQh77pIXCsq998c8hbhSTI/azTty1Z6N53dmAudKHhy573j3yvRLsX2BSp8YpLtoCEG8E9DJe+8zUh4A==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       },
@@ -2470,6 +2488,301 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@typescript-eslint/eslint-plugin": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.65.0.tgz",
+      "integrity": "sha512-IEgob78X12rHpUmtcwFsXhZdVGJtwTVP8FiCLZkR6GlYVrl2PcuB+KhCE5BlVC/eQpQnu8WXRtkHZuPar+gCRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/regexpp": "^4.12.2",
+        "@typescript-eslint/scope-manager": "8.65.0",
+        "@typescript-eslint/type-utils": "8.65.0",
+        "@typescript-eslint/utils": "8.65.0",
+        "@typescript-eslint/visitor-keys": "8.65.0",
+        "ignore": "^7.0.5",
+        "natural-compare": "^1.4.0",
+        "ts-api-utils": "^2.5.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/parser": "^8.65.0",
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.6.tgz",
+      "integrity": "sha512-BAg6QkE8W+TuQLrrw0Ugr7HegXduRuuj8/ti2kSOc+jz1dmx8/WNcjr6XGnq5YpDWxFwwaavqD0+jIUOKelTsw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/@typescript-eslint/parser": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.65.0.tgz",
+      "integrity": "sha512-CZ4nMxWwgu1HEEFNkeaCptra9QCtkmKdgf3sWh1rl1trIhmxLilgTV4cwcbQ4wemnT4sWQN8CaKOmdYx+g2gMA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/scope-manager": "8.65.0",
+        "@typescript-eslint/types": "8.65.0",
+        "@typescript-eslint/typescript-estree": "8.65.0",
+        "@typescript-eslint/visitor-keys": "8.65.0",
+        "debug": "^4.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/project-service": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.65.0.tgz",
+      "integrity": "sha512-SxnPhbTsGahizDgbu7oqFH/xVtzIqMd/s+WtnSxNxJZJpLbdT5IPdzg8EZxO3+PoKahXmwJLeNQOpKJb3/bi7Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/tsconfig-utils": "^8.65.0",
+        "@typescript-eslint/types": "^8.65.0",
+        "debug": "^4.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/scope-manager": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.65.0.tgz",
+      "integrity": "sha512-Esbl8OSYiVxBokYgWPf7VVWg/BE798wXhimnn9ML9Pt5qoDf8bfQlgjlKXR/k98+AcNzlLKYrpCcrcuZ9DZLgg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.65.0",
+        "@typescript-eslint/visitor-keys": "8.65.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/tsconfig-utils": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.65.0.tgz",
+      "integrity": "sha512-j6GzGqCiRdA7Qhur2VVmKZAkBLfnHFQfx4TaJGL9RMveZqCo48jSHHO0DTgizEnGhtWnqmbtCUSrqSkdiY/0Hg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/type-utils": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.65.0.tgz",
+      "integrity": "sha512-YjaZ7PRI5qY7ax2L3PbvX0rRyGtipAReCWs0mhhDBHjH/vl0g0BonaGXrKdKpMbIIsMIwDgbk/xzkBTyAltS5g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.65.0",
+        "@typescript-eslint/typescript-estree": "8.65.0",
+        "@typescript-eslint/utils": "8.65.0",
+        "debug": "^4.4.3",
+        "ts-api-utils": "^2.5.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/types": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.65.0.tgz",
+      "integrity": "sha512-JSSwWNy+H0E/01jJEM+hrX6N0OFDzFzeIhHFSAS01tlVaevpG8cFyYRPhS5yjGOvBUx3sqQHVMjCL1CAZZMxBg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.65.0.tgz",
+      "integrity": "sha512-JboAE2swaYt4tb1fHhHTABE2K+OLy09XfcTbhnk4Pw96f9dd2e9iYsJ28gBggHlo5z5x1rkyWvcPoTuNTd4oGg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/project-service": "8.65.0",
+        "@typescript-eslint/tsconfig-utils": "8.65.0",
+        "@typescript-eslint/types": "8.65.0",
+        "@typescript-eslint/visitor-keys": "8.65.0",
+        "debug": "^4.4.3",
+        "minimatch": "^10.2.2",
+        "semver": "^7.7.3",
+        "tinyglobby": "^0.2.15",
+        "ts-api-utils": "^2.5.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.8.tgz",
+      "integrity": "sha512-JZyDyq3D4AUifKTPOB7DELf6XsB3WdPuNxCtob1vFXPsSXhdAiHBWJ/tJ8HAc9aH84BK+5JFZLNkJKx3G9kzQg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
+      "version": "10.2.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz",
+      "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.8"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": {
+      "version": "7.8.5",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@typescript-eslint/utils": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.65.0.tgz",
+      "integrity": "sha512-gXiwIHsYreboxeJucHKPvgwl7dXt50mF8s1/c00cP/WoVTyWKFdtfhRWwZiXYFU5H2O8vVoSLNrexFZjYS/SGA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.9.1",
+        "@typescript-eslint/scope-manager": "8.65.0",
+        "@typescript-eslint/types": "8.65.0",
+        "@typescript-eslint/typescript-estree": "8.65.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/visitor-keys": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.65.0.tgz",
+      "integrity": "sha512-8C71BQkGjiMmXtop7pHVJu1l2NNShFdkCyD6a2ezzs5vU/L3LRtb69EtcteFwz0mYMPzIgOw0n6OV4VBUWZd7A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.65.0",
+        "eslint-visitor-keys": "^5.0.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
+      "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
     "node_modules/@use-gesture/core": {
       "version": "10.3.1",
       "resolved": "https://registry.npmjs.org/@use-gesture/core/-/core-10.3.1.tgz",
@@ -5137,6 +5450,26 @@
         }
       }
     },
+    "node_modules/eslint-plugin-react-hooks": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.1.1.tgz",
+      "integrity": "sha512-f2I7Gw6JbvCexzIInuSbZpfdQ44D7iqdWX01FKLvrPgqxoE7oMj8clOfto8U6vYiz4yd5oKu39rRSVOe1zRu0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.24.4",
+        "@babel/parser": "^7.24.4",
+        "hermes-parser": "^0.25.1",
+        "zod": "^3.25.0 || ^4.0.0",
+        "zod-validation-error": "^3.5.0 || ^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 || ^10.0.0"
+      }
+    },
     "node_modules/eslint-scope": {
       "version": "8.4.0",
       "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
@@ -5165,6 +5498,19 @@
         "url": "https://opencollective.com/eslint"
       }
     },
+    "node_modules/eslint/node_modules/@eslint/js": {
+      "version": "9.39.3",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.3.tgz",
+      "integrity": "sha512-1B1VkCq6FuUNlQvlBYb+1jDu/gV297TIs/OeiaSR9l1H27SVW55ONE1e1Vp16NqP683+xEGzxYtv4XCiDPaQiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
     "node_modules/eslint/node_modules/brace-expansion": {
       "version": "1.1.12",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
@@ -5716,10 +6062,11 @@
       }
     },
     "node_modules/globals": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
-      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "version": "17.8.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-17.8.0.tgz",
+      "integrity": "sha512-Zz/LMDZScFmkakeL2cTHzf+PbWKdpU3uclqkZT7TjDG58j5WPt0PpA+n9uPI24fZtlw07q0OtEi84K+umsRzqQ==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=18"
       },
@@ -5845,6 +6192,23 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/hermes-estree": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz",
+      "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/hermes-parser": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz",
+      "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hermes-estree": "0.25.1"
+      }
+    },
     "node_modules/hls.js": {
       "version": "1.6.15",
       "resolved": "https://registry.npmjs.org/hls.js/-/hls.js-1.6.15.tgz",
@@ -8314,6 +8678,19 @@
         "utf8-byte-length": "^1.0.1"
       }
     },
+    "node_modules/ts-api-utils": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz",
+      "integrity": "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.12"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4"
+      }
+    },
     "node_modules/ts-interface-checker": {
       "version": "0.1.13",
       "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
@@ -8392,6 +8769,30 @@
         "node": ">=14.17"
       }
     },
+    "node_modules/typescript-eslint": {
+      "version": "8.65.0",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.65.0.tgz",
+      "integrity": "sha512-/ggrHAwyjENDusvyxbuqxAC2dTnZg/Z8F+fgQtYIz+L6n/9HfSlEZcFGV/NsMNa6CkGk0xUjUAFwC0vHOflvIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/eslint-plugin": "8.65.0",
+        "@typescript-eslint/parser": "8.65.0",
+        "@typescript-eslint/typescript-estree": "8.65.0",
+        "@typescript-eslint/utils": "8.65.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
     "node_modules/undici-types": {
       "version": "6.21.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
@@ -9168,6 +9569,29 @@
         "node": ">= 10"
       }
     },
+    "node_modules/zod": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-validation-error": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/zod-validation-error/-/zod-validation-error-4.0.2.tgz",
+      "integrity": "sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.0 || ^4.0.0"
+      }
+    },
     "node_modules/zustand": {
       "version": "5.0.11",
       "resolved": "https://registry.npmjs.org/zustand/-/zustand-5.0.11.tgz",
diff --git a/package.json b/package.json
index 64ef178f..0c0b56cd 100644
--- a/package.json
+++ b/package.json
@@ -13,7 +13,7 @@
     "prepare-resources": "node scripts/download-python-embed.js",
     "test": "npm run test:py && npm run test:node",
     "test:py": "node scripts/run-pytests.mjs",
-    "test:node": "node --test --experimental-strip-types --experimental-loader ./scripts/node-ts-extensionless-loader.mjs src/shared/types/assetLibrary.test.ts src/areas/generate/assetLibraryProjection.test.ts src/areas/generate/assetLibraryService.test.ts src/areas/generate/assetLibraryUi.test.ts electron/main/artifact-registry-service.test.ts electron/main/extension-path-guard.test.ts electron/preload/artifact-registry-preload.test.ts && node --test electron/main/*.test.mjs src/**/*.test.mjs",
+    "test:node": "node --test --experimental-strip-types --experimental-loader ./scripts/node-ts-extensionless-loader.mjs src/shared/types/assetLibrary.test.ts src/areas/generate/assetLibraryProjection.test.ts src/areas/generate/assetLibraryService.test.ts src/areas/generate/assetLibraryUi.test.ts src/areas/generate/components/liveTexture.test.ts src/areas/workflows/mergeNodeText.test.ts electron/main/artifact-registry-service.test.ts electron/main/extension-path-guard.test.ts electron/main/texture-watch-service.test.ts electron/preload/artifact-registry-preload.test.ts electron/preload/texture-watch-preload.test.ts && node --test electron/main/*.test.mjs src/**/*.test.mjs",
     "package": "cross-env CSC_IDENTITY_AUTO_DISCOVERY=false npm run build && npm run prepare-resources && electron-builder",
     "package:mac": "cross-env CSC_IDENTITY_AUTO_DISCOVERY=false npm run build && npm run prepare-resources && electron-builder --mac --arm64",
     "lint": "eslint ."
diff --git a/src/App.tsx b/src/App.tsx
index 2de17224..d6a596e7 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,15 +1,15 @@
 import { useEffect, useLayoutEffect, useState } from 'react'
-import { useAppStore, type UiScale } from '@shared/stores/appStore'
+import { useAppStore } from '@shared/stores/appStore'
 import FirstRunSetup from '@areas/setup/FirstRunSetup'
 import MainLayout from '@shared/components/layout/MainLayout'
 import { UpdateModal } from '@shared/components/ui/UpdateModal'
 import { ErrorModal } from '@shared/components/ui/ErrorModal'
 import { Toast } from '@shared/components/ui/Toast'
 
-const UI_SCALE_FACTORS: Record<UiScale, number> = { small: 0.875, medium: 1, large: 1.25, 'very-large': 1.5 }
 
 export default function App(): JSX.Element {
-  const { checkSetup, setupStatus, initApp, backendStatus, showError, useAtkinsonFont, uiScale } = useAppStore()
+  const { checkSetup, setupStatus, initApp, backendStatus, showError, useAtkinsonFont,
+          uiZoomFactor, setUiZoomFactor } = useAppStore()
   const [updateVersion, setUpdateVersion] = useState<string | null>(null)
   const [currentVersion, setCurrentVersion] = useState<string>('')
 
@@ -34,8 +34,23 @@ export default function App(): JSX.Element {
         ? "'Atkinson Hyperlegible', system-ui, sans-serif"
         : "'Inter', system-ui, sans-serif"
     )
-    window.electron.ui.setZoomFactor(UI_SCALE_FACTORS[uiScale])
-  }, [useAtkinsonFont, uiScale])
+    window.electron.ui.setZoomFactor(uiZoomFactor)
+  }, [useAtkinsonFont, uiZoomFactor])
+
+  // Ctrl/Cmd +/-/0 is caught by the main process, because Chromium claims those
+  // chords before the page sees them. It only tells us WHICH way to go — the
+  // size itself lives here, in the one place that is saved and re-applied on
+  // launch. Keeping a second copy in the main process is what used to lose the
+  // setting on every restart: it restored the saved zoom, then this component
+  // mounted and overwrote it.
+  useEffect(() => {
+    window.electron.ui.onZoomStep((step) => {
+      if (step === 0) setUiZoomFactor(1)
+      else setUiZoomFactor(Number((useAppStore.getState().uiZoomFactor + step * 0.1).toFixed(2)))
+    })
+    return () => window.electron.ui.offZoomStep()
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- store actions are stable
+  }, [])
 
   useEffect(() => {
     if (setupStatus === 'done') initApp()
diff --git a/src/areas/generate/GeneratePage.tsx b/src/areas/generate/GeneratePage.tsx
index a6dbe4f3..f9561056 100644
--- a/src/areas/generate/GeneratePage.tsx
+++ b/src/areas/generate/GeneratePage.tsx
@@ -1,5 +1,5 @@
-import { useState, useRef, useCallback, useEffect, useMemo } from 'react'
-import type { ReactNode } from 'react'
+import { useState, useRef, useCallback, useEffect, useLayoutEffect, useMemo } from 'react'
+import type { ReactNode, RefObject } from 'react'
 import { useAppStore, DEFAULT_LIGHT_SETTINGS } from '@shared/stores/appStore'
 import type { GenerationJob, LightSettings } from '@shared/stores/appStore'
 import { useApi } from '@shared/hooks/useApi'
@@ -9,24 +9,66 @@ import Viewer3D from './components/Viewer3D'
 import WorkflowPanel from './components/WorkflowPanel'
 import { getDefaultAssetLibraryService } from './assetLibraryService'
 import { resolveAssetLibraryOpenTarget, type ProjectedAssetLibraryEntry } from './assetLibraryProjection'
+import type { AssetLibraryPreviewClip } from '../../shared/types/assetLibrary'
 import {
+  ASSET_LIBRARY_KIND_FILTERS,
+  ASSET_LIBRARY_POLY_FILTERS,
   ASSET_LIBRARY_SORT_OPTIONS,
+  buildAssetLibraryProjectGroups,
   buildAssetLibraryOpenRequest,
+  clampAssetLibraryPanelHeight,
+  clampAssetLibraryPanelWidth,
+  createDefaultAssetLibraryFilters,
   createAssetLibraryOpenJob,
   describeAssetLibraryOpenability,
-  filterAssetLibraryScopeGroups,
+  findAssetLibraryMotionClipIndex,
+  formatAssetLibraryClipName,
+  getAssetLibraryPanelLayout,
   getDefaultAssetLibraryCollapsedSectionKeys,
+  getStoredAssetLibraryPanelHeight,
+  getStoredAssetLibraryPanelWidth,
   isAssetLibraryEntryOpenable,
+  isAssetLibrarySectionExpanded,
   resolveOpenPanelAfterLibrarySelection,
+  storeAssetLibraryPanelHeight,
+  storeAssetLibraryPanelWidth,
   toggleAssetLibrarySectionKey,
+  type AssetLibraryFilters,
+  type AssetLibraryLineageFamily,
   type AssetLibrarySortMode,
+  type AssetLibraryViewMode,
   type GenerateOpenPanel,
 } from './assetLibraryUi'
 
 const MIN_WIDTH = 220
-const MAX_WIDTH = 520
+const MAX_WIDTH = 900
 const DEFAULT_WIDTH = 320
 
+const PANEL_WIDTH_STORAGE_KEY = 'modly-panel-width'
+
+function clampPanelWidth(width: number): number {
+  return Math.min(MAX_WIDTH, Math.max(MIN_WIDTH, width))
+}
+
+/** Reads the user's saved Generate panel width, falling back to the default when unset, invalid, or unreadable. */
+function getStoredPanelWidth(): number {
+  try {
+    const raw = Number(localStorage.getItem(PANEL_WIDTH_STORAGE_KEY))
+    return Number.isFinite(raw) && raw > 0 ? clampPanelWidth(raw) : DEFAULT_WIDTH
+  } catch {
+    return DEFAULT_WIDTH
+  }
+}
+
+/** Persists the Generate panel width so it survives app restarts. */
+function storePanelWidth(width: number): void {
+  try {
+    localStorage.setItem(PANEL_WIDTH_STORAGE_KEY, String(width))
+  } catch {
+    // Ignore quota/private-mode failures — the panel just won't remember its size.
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Export dropdown
 // ---------------------------------------------------------------------------
@@ -359,6 +401,10 @@ function AssetLibraryToggleButton({
   )
 }
 
+// A stable empty-array reference for entries with no preview manifest yet, so
+// rows don't see a fresh `[]` identity on every parent re-render.
+const EMPTY_PREVIEW_CLIPS: AssetLibraryPreviewClip[] = []
+
 function AssetLibraryPopover({
   entries,
   selectedEntryId,
@@ -367,14 +413,28 @@ function AssetLibraryPopover({
   error,
   searchQuery,
   sortMode,
+  viewMode,
+  filters,
   collapsedSectionKeys,
-  onSelectEntry,
+  thumbnails,
+  previews,
+  panelWidth,
+  panelHeight,
+  anchorRef,
+  viewerEntryId,
+  viewerClipName,
+  onActivateEntry,
+  onSelectViewerClip,
   onSearchQueryChange,
   onSortModeChange,
+  onViewModeChange,
+  onFiltersChange,
   onToggleSection,
-  onOpenSelected,
+  onFetchPreviewFrame,
   onRefresh,
   onClose,
+  onResizeMouseDown,
+  onResizeHeightMouseDown,
 }: {
   entries: ProjectedAssetLibraryEntry[]
   selectedEntryId: string | null
@@ -383,70 +443,129 @@ function AssetLibraryPopover({
   error: string | null
   searchQuery: string
   sortMode: AssetLibrarySortMode
+  viewMode: AssetLibraryViewMode
+  filters: AssetLibraryFilters
   collapsedSectionKeys: string[]
-  onSelectEntry: (entryId: string) => void
+  /** Data URLs keyed by workspacePath, populated lazily as thumbnails load. */
+  thumbnails: Record<string, string>
+  /** Preview clip metadata keyed by workspacePath; empty until a preview manifest exists for that asset. */
+  previews: Record<string, AssetLibraryPreviewClip[]>
+  panelWidth: number
+  panelHeight: number
+  anchorRef: RefObject<HTMLDivElement | null>
+  viewerEntryId: string | null
+  viewerClipName: string | null
+  /** A row click both selects and, when the entry is openable, opens it immediately — no second confirming click. */
+  onActivateEntry: (entryId: string) => void
+  onSelectViewerClip: (entryId: string, clip: string) => void
   onSearchQueryChange: (value: string) => void
   onSortModeChange: (value: AssetLibrarySortMode) => void
+  onViewModeChange: (value: AssetLibraryViewMode) => void
+  onFiltersChange: (value: AssetLibraryFilters) => void
   onToggleSection: (sectionKey: string) => void
-  onOpenSelected: () => void
+  onFetchPreviewFrame: (workspacePath: string, clip: string) => Promise<string | null>
   onRefresh: () => void
   onClose: () => void
+  onResizeMouseDown: (event: React.MouseEvent) => void
+  onResizeHeightMouseDown: (event: React.MouseEvent) => void
 }) {
-  const scopeGroups = filterAssetLibraryScopeGroups(entries, searchQuery, sortMode)
-  const visibleEntryIds = new Set(scopeGroups.flatMap((scopeGroup) => scopeGroup.entryGroups.flatMap((group) => group.entries.map((entry) => entry.id))))
-  const selectedEntry = selectedEntryId && visibleEntryIds.has(selectedEntryId)
-    ? entries.find((entry) => entry.id === selectedEntryId) ?? null
-    : null
+  const projectGroups = buildAssetLibraryProjectGroups(entries, searchQuery, sortMode, filters)
   const normalizedSearchQuery = searchQuery.trim()
-  const openDisabled = !selectedEntry || !isAssetLibraryEntryOpenable(selectedEntry) || loading || opening
-  const selectedMessage = selectedEntry
-    ? describeAssetLibraryOpenability(selectedEntry)
-    : scopeGroups.length === 0 && normalizedSearchQuery
-      ? `No workspace assets match “${normalizedSearchQuery}”.`
-      : 'Select an asset to open it in Generate.'
+  const hasActiveFilters = filters.kind !== 'all' || filters.poly !== 'all' || filters.needsAttention
+  const hasActiveDiscovery = normalizedSearchQuery.length > 0 || hasActiveFilters
+  const familyCount = projectGroups.reduce((count, group) => count + group.families.length, 0)
+  const versionCount = projectGroups.reduce((count, group) => count + group.entryCount, 0)
+  const [layout, setLayout] = useState<ReturnType<typeof getAssetLibraryPanelLayout> | null>(null)
+
+  const updateLayout = useCallback(() => {
+    const anchor = anchorRef.current?.getBoundingClientRect()
+    if (!anchor) return
+    setLayout(getAssetLibraryPanelLayout(
+      anchor,
+      { width: window.innerWidth, height: window.innerHeight },
+      panelWidth,
+      panelHeight,
+    ))
+  }, [anchorRef, panelHeight, panelWidth])
+
+  useLayoutEffect(() => {
+    updateLayout()
+    window.addEventListener('resize', updateLayout)
+    window.visualViewport?.addEventListener('resize', updateLayout)
+    const observer = new ResizeObserver(updateLayout)
+    observer.observe(document.documentElement)
+    return () => {
+      window.removeEventListener('resize', updateLayout)
+      window.visualViewport?.removeEventListener('resize', updateLayout)
+      observer.disconnect()
+    }
+  }, [updateLayout])
 
   return (
     <div
       role="dialog"
       aria-label="Workspace library"
-      className="absolute top-full left-0 mt-1 z-50 w-[320px] max-w-[calc(100vw-2rem)] bg-zinc-900 border border-zinc-700/60 rounded-xl p-3 flex flex-col gap-3 shadow-xl"
+      style={layout
+        ? { left: layout.left, top: layout.top, width: layout.width, height: layout.height }
+        : { visibility: 'hidden' }
+      }
+      className="fixed z-50 bg-zinc-900 border border-zinc-700/60 rounded-xl p-3 flex flex-col gap-3 shadow-xl overflow-y-auto overflow-x-hidden"
     >
-      <div className="flex items-center justify-between gap-2">
-        <div>
-          <p className="text-[10px] text-zinc-500 uppercase tracking-wider">Workspace library</p>
-          <p className="text-xs text-zinc-300">Select a workspace asset and open the supported source in Generate.</p>
+      <div className="flex flex-wrap items-center justify-between gap-2 shrink-0">
+        <div className="min-w-0">
+          <p className="text-[10px] text-zinc-500 uppercase tracking-wider">Asset Library</p>
+          <p className="text-xs text-zinc-300">Browse models by project, traits, and version family.</p>
+        </div>
+        <div className="flex items-center gap-2">
+          <button
+            type="button"
+            onClick={onRefresh}
+            disabled={loading || opening}
+            className="px-2 py-1 text-[11px] text-zinc-400 hover:text-zinc-200 bg-zinc-800 hover:bg-zinc-700 disabled:opacity-50 rounded-lg transition-colors"
+          >
+            Refresh
+          </button>
+          <button
+            type="button"
+            onClick={onClose}
+            className="px-2 py-1 text-[11px] text-zinc-400 hover:text-zinc-200 bg-zinc-800 hover:bg-zinc-700 rounded-lg transition-colors"
+          >
+            Close
+          </button>
         </div>
-        <button
-          type="button"
-          onClick={onClose}
-          className="px-2 py-1 text-[11px] text-zinc-400 hover:text-zinc-200 bg-zinc-800 hover:bg-zinc-700 rounded-lg transition-colors"
-        >
-          Close library
-        </button>
       </div>
 
-      <button
-        type="button"
-        onClick={onRefresh}
-        disabled={loading || opening}
-        className="self-start px-2.5 py-1.5 text-[11px] text-zinc-300 bg-zinc-800 hover:bg-zinc-700 disabled:opacity-50 disabled:pointer-events-none rounded-lg transition-colors"
-      >
-        Refresh assets
-      </button>
+      {/* Resize handle — drag to widen/narrow the library panel; size is persisted. */}
+      <div
+        onMouseDown={onResizeMouseDown}
+        role="separator"
+        aria-orientation="vertical"
+        aria-label="Resize workspace library panel width"
+        className="absolute top-0 right-0 bottom-0 z-20 w-1.5 cursor-col-resize hover:bg-violet-400/40 active:bg-violet-400/60 transition-colors rounded-r-xl"
+      />
+
+      {/* Resize handle — drag to grow/shrink the library panel; size is persisted. */}
+      <div
+        onMouseDown={onResizeHeightMouseDown}
+        role="separator"
+        aria-orientation="horizontal"
+        aria-label="Resize workspace library panel height"
+        className="absolute bottom-0 left-0 right-0 z-20 h-1.5 cursor-row-resize hover:bg-violet-400/40 active:bg-violet-400/60 transition-colors rounded-b-xl"
+      />
 
-      <div className="flex items-end gap-2">
-        <div className="flex min-w-0 flex-1 flex-col gap-1.5">
-          <label htmlFor="asset-library-search" className="text-[11px] text-zinc-300">Search workspace assets</label>
+      <div className="flex flex-wrap items-end gap-2 shrink-0">
+        <div className="flex min-w-[min(100%,16rem)] flex-1 flex-col gap-1.5">
+          <label htmlFor="asset-library-search" className="text-[11px] text-zinc-300">Search assets</label>
           <input
             id="asset-library-search"
             type="search"
             value={searchQuery}
             onChange={(event) => onSearchQueryChange(event.target.value)}
-            placeholder="Search by name, path, scope, or capability"
-            className="bg-zinc-800 border border-zinc-700 rounded-lg px-2.5 py-1.5 text-xs text-zinc-200 w-full focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-violet-400"
+            placeholder="Search names, projects, tags, clips, or locations"
+            className="appearance-none bg-zinc-800 border border-zinc-700 rounded-lg px-2.5 py-1.5 text-xs text-zinc-200 w-full focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-violet-400"
           />
         </div>
-        <div className="flex w-24 shrink-0 flex-col gap-1.5">
+        <div className="flex w-36 max-w-full shrink-0 flex-col gap-1.5">
           <label htmlFor="asset-library-sort" className="text-[11px] text-zinc-300">Sort</label>
           <select
             id="asset-library-sort"
@@ -459,76 +578,145 @@ function AssetLibraryPopover({
             ))}
           </select>
         </div>
+        <div className="flex shrink-0 rounded-lg border border-zinc-700 bg-zinc-800 p-0.5" aria-label="Library view">
+          {(['gallery', 'list'] as const).map((mode) => (
+            <button
+              key={mode}
+              type="button"
+              aria-pressed={viewMode === mode}
+              onClick={() => onViewModeChange(mode)}
+              className={`rounded-md px-2.5 py-1.5 text-[11px] capitalize transition-colors ${
+                viewMode === mode ? 'bg-violet-600 text-white' : 'text-zinc-400 hover:text-zinc-200'
+              }`}
+            >
+              {mode}
+            </button>
+          ))}
+        </div>
       </div>
 
+      <div className="shrink-0 space-y-2 rounded-lg border border-zinc-800 bg-zinc-950/40 p-2.5">
+        <div className="flex flex-wrap items-center gap-1.5">
+          <span className="mr-1 text-[10px] font-medium uppercase tracking-wider text-zinc-500">What it is</span>
+          {ASSET_LIBRARY_KIND_FILTERS.map((option) => (
+            <button
+              key={option.value}
+              type="button"
+              aria-pressed={filters.kind === option.value}
+              onClick={() => onFiltersChange({ ...filters, kind: option.value })}
+              className={`rounded-full border px-2.5 py-1 text-[10px] transition-colors ${
+                filters.kind === option.value
+                  ? 'border-violet-400/70 bg-violet-500/20 text-violet-100'
+                  : 'border-zinc-700 bg-zinc-800 text-zinc-400 hover:text-zinc-200'
+              }`}
+            >
+              {option.label}
+            </button>
+          ))}
+        </div>
+        <div className="flex flex-wrap items-center gap-1.5">
+          <span className="mr-1 text-[10px] font-medium uppercase tracking-wider text-zinc-500">File weight</span>
+          {ASSET_LIBRARY_POLY_FILTERS.map((option) => (
+            <button
+              key={option.value}
+              type="button"
+              aria-pressed={filters.poly === option.value}
+              onClick={() => onFiltersChange({ ...filters, poly: option.value })}
+              className={`rounded-full border px-2.5 py-1 text-[10px] transition-colors ${
+                filters.poly === option.value
+                  ? 'border-sky-400/70 bg-sky-500/15 text-sky-100'
+                  : 'border-zinc-700 bg-zinc-800 text-zinc-400 hover:text-zinc-200'
+              }`}
+            >
+              {option.label}
+            </button>
+          ))}
+          <button
+            type="button"
+            aria-pressed={filters.needsAttention}
+            onClick={() => onFiltersChange({ ...filters, needsAttention: !filters.needsAttention })}
+            className={`ml-auto rounded-full border px-2.5 py-1 text-[10px] transition-colors ${
+              filters.needsAttention
+                ? 'border-amber-400/70 bg-amber-500/15 text-amber-100'
+                : 'border-zinc-700 bg-zinc-800 text-zinc-400 hover:text-zinc-200'
+            }`}
+          >
+            Needs a name
+          </button>
+        </div>
+      </div>
+
+      {error && (
+        <p role="alert" className="shrink-0 rounded-lg border border-amber-800/50 bg-amber-950/40 px-3 py-2 text-[11px] text-amber-300">
+          {error}
+        </p>
+      )}
+
       {loading ? (
-        <p role="status" className="text-xs text-zinc-400">Loading workspace assets…</p>
-      ) : scopeGroups.length === 0 && !normalizedSearchQuery ? (
-        <p role="status" className="text-xs text-zinc-500">No workspace assets are indexed yet.</p>
-      ) : scopeGroups.length === 0 ? (
-        <p role="status" className="text-xs text-zinc-500">{`No workspace assets match “${normalizedSearchQuery}”.`}</p>
+        <p role="status" className="flex min-h-40 items-center justify-center text-xs text-zinc-400">Loading workspace assets…</p>
+      ) : projectGroups.length === 0 && !hasActiveDiscovery ? (
+        <p role="status" className="flex min-h-40 items-center justify-center text-xs text-zinc-500">No workspace assets are indexed yet.</p>
+      ) : projectGroups.length === 0 ? (
+        <p role="status" className="flex min-h-40 items-center justify-center text-center text-xs text-zinc-500">
+          No assets match these search and filter choices.
+        </p>
       ) : (
-        <div role="list" aria-label="Workspace library assets" className="max-h-64 overflow-y-auto rounded-lg border border-zinc-800 bg-zinc-950/40">
-          {scopeGroups.map((scopeGroup) => {
-            const scopeExpanded = !collapsedSectionKeys.includes(scopeGroup.sectionKey)
-            const scopeRegionId = `asset-library-${scopeGroup.sectionKey.replace(/[^a-z0-9-]+/gi, '-')}`
+        <div className="shrink-0 rounded-lg border border-zinc-800 bg-zinc-950/40">
+          <div className="sticky top-0 z-10 flex flex-wrap items-center justify-between gap-1 border-b border-zinc-800 bg-zinc-950/95 px-3 py-2 backdrop-blur">
+            <span className="text-[10px] uppercase tracking-wider text-zinc-500">Grouped by project</span>
+            <span className="text-[10px] text-zinc-500">{familyCount} families · {versionCount} versions</span>
+          </div>
+          {projectGroups.map((projectGroup) => {
+            const projectExpanded = isAssetLibrarySectionExpanded(collapsedSectionKeys, projectGroup.sectionKey, hasActiveDiscovery)
+            const projectRegionId = `asset-library-${projectGroup.sectionKey.replace(/[^a-z0-9-]+/gi, '-')}`
             return (
-              <section key={scopeGroup.sectionKey} role="group" aria-label={`Source scope ${scopeGroup.sourceScopeLabel}`} className="border-b border-zinc-800 last:border-b-0">
+              <section key={projectGroup.sectionKey} role="group" aria-label={`Project ${projectGroup.projectLabel}`} className="border-b border-zinc-800 last:border-b-0">
                 <button
                   type="button"
-                  aria-expanded={scopeExpanded}
-                  aria-controls={scopeRegionId}
-                  onClick={() => onToggleSection(scopeGroup.sectionKey)}
-                  className="flex w-full items-center justify-between gap-2 px-3 py-2 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-violet-400"
+                  aria-expanded={projectExpanded}
+                  aria-controls={projectRegionId}
+                  onClick={() => onToggleSection(projectGroup.sectionKey)}
+                  disabled={hasActiveDiscovery}
+                  className="flex w-full flex-wrap items-center justify-between gap-2 bg-zinc-900/80 px-3 py-2.5 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-violet-400 disabled:pointer-events-none"
                 >
-                  <span className="text-[10px] font-semibold uppercase tracking-[0.18em] text-zinc-300">{scopeGroup.sourceScopeLabel}</span>
-                  <span className="text-[10px] text-zinc-500">{scopeExpanded ? 'Hide' : 'Show'}</span>
+                  <span className="flex items-center gap-2">
+                    <span className={`text-xs font-semibold ${projectGroup.projectKey === 'needs-project' ? 'text-amber-200' : 'text-zinc-200'}`}>
+                      {projectGroup.projectLabel}
+                    </span>
+                    {projectGroup.projectKey === 'needs-project' && (
+                      <span className="rounded-full bg-amber-500/15 px-2 py-0.5 text-[9px] text-amber-200">Add project metadata</span>
+                    )}
+                  </span>
+                  <span className="text-[10px] text-zinc-500">
+                    {projectGroup.families.length} {projectGroup.families.length === 1 ? 'family' : 'families'} · {projectGroup.entryCount} versions · {projectExpanded ? 'Hide' : 'Show'}
+                  </span>
                 </button>
-                {scopeExpanded && (
-                  <div id={scopeRegionId}>
-                    {scopeGroup.entryGroups.map((group) => {
-                      const capabilityExpanded = !collapsedSectionKeys.includes(group.sectionKey)
-                      const capabilityRegionId = `asset-library-${group.sectionKey.replace(/[^a-z0-9-]+/gi, '-')}`
-                      return (
-                        <section key={group.sectionKey} role="group" aria-label={`Capability category ${group.capabilityLabel}`} className="border-t border-zinc-800 first:border-t-0">
-                          <button
-                            type="button"
-                            aria-expanded={capabilityExpanded}
-                            aria-controls={capabilityRegionId}
-                            onClick={() => onToggleSection(group.sectionKey)}
-                            className="flex w-full items-center justify-between gap-2 px-4 py-2 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-violet-400"
-                          >
-                            <span className="text-[10px] font-semibold uppercase tracking-[0.18em] text-zinc-400">{group.capabilityLabel}</span>
-                            <span className="text-[10px] text-zinc-500">{capabilityExpanded ? 'Hide' : 'Show'}</span>
-                          </button>
-                          {capabilityExpanded && (
-                            <div id={capabilityRegionId}>
-                              {group.entries.map((entry) => {
-                                const selected = entry.id === selectedEntryId
-                                return (
-                                  <button
-                                    key={entry.id}
-                                    type="button"
-                                    role="listitem"
-                                    aria-pressed={selected}
-                                    aria-label={`Select library asset ${entry.displayName}`}
-                                    onClick={() => onSelectEntry(entry.id)}
-                                    className={`w-full text-left px-4 py-2 border-t border-zinc-800 first:border-t-0 transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-violet-400
-                                      ${selected ? 'bg-violet-500/10 text-zinc-100' : 'text-zinc-300 hover:bg-zinc-800/80'}`}
-                                  >
-                                    <div className="flex items-center justify-between gap-2">
-                                      <span className="text-xs font-medium">{entry.displayName}</span>
-                                      <span className="text-[10px] uppercase tracking-wider text-zinc-500">{entry.capability ?? entry.state.replace(/-/g, ' ')}</span>
-                                    </div>
-                                    <p className="mt-1 truncate text-[10px] text-zinc-500">{entry.workspacePath}</p>
-                                  </button>
-                                )
-                              })}
-                            </div>
-                          )}
-                        </section>
-                      )
-                    })}
+                {projectExpanded && (
+                  <div
+                    id={projectRegionId}
+                    role="list"
+                    aria-label={`${projectGroup.projectLabel} asset families`}
+                    className={viewMode === 'gallery'
+                      ? 'grid grid-cols-[repeat(auto-fill,minmax(min(100%,13rem),1fr))] gap-3 p-3'
+                      : 'divide-y divide-zinc-800'
+                    }
+                  >
+                    {projectGroup.families.map((family) => (
+                      <AssetLibraryFamilyCard
+                        key={family.key}
+                        family={family}
+                        viewMode={viewMode}
+                        selectedEntryId={selectedEntryId}
+                        disabled={opening}
+                        thumbnails={thumbnails}
+                        previews={previews}
+                        viewerEntryId={viewerEntryId}
+                        viewerClipName={viewerClipName}
+                        onActivateEntry={onActivateEntry}
+                        onSelectViewerClip={onSelectViewerClip}
+                        onFetchPreviewFrame={onFetchPreviewFrame}
+                      />
+                    ))}
                   </div>
                 )}
               </section>
@@ -536,32 +724,331 @@ function AssetLibraryPopover({
           })}
         </div>
       )}
+    </div>
+  )
+}
 
-      <div className="rounded-lg border border-zinc-800 bg-zinc-950/40 px-3 py-2">
-        <p className="text-[11px] text-zinc-400">{selectedMessage}</p>
-        {error && <p role="alert" className="mt-2 text-[11px] text-amber-300">{error}</p>}
-      </div>
+/**
+ * One semantic asset family. Gallery cards load their active motion clip
+ * immediately so animation is visible without a precision hover. List rows
+ * retain the compact scanner from v2 and lazy-load animation on hover.
+ */
+function AssetLibraryFamilyCard({
+  family,
+  viewMode,
+  selectedEntryId,
+  disabled,
+  thumbnails,
+  previews,
+  viewerEntryId,
+  viewerClipName,
+  onActivateEntry,
+  onSelectViewerClip,
+  onFetchPreviewFrame,
+}: {
+  family: AssetLibraryLineageFamily
+  viewMode: AssetLibraryViewMode
+  selectedEntryId: string | null
+  disabled: boolean
+  thumbnails: Record<string, string>
+  previews: Record<string, AssetLibraryPreviewClip[]>
+  viewerEntryId: string | null
+  viewerClipName: string | null
+  onActivateEntry: (entryId: string) => void
+  onSelectViewerClip: (entryId: string, clip: string) => void
+  onFetchPreviewFrame: (workspacePath: string, clip: string) => Promise<string | null>
+}) {
+  const entry = family.primaryEntry
+  const thumbnailDataUrl = thumbnails[entry.workspacePath]
+  const previewClips = previews[entry.workspacePath] ?? EMPTY_PREVIEW_CLIPS
+  const selected = family.entries.some((candidate) => candidate.id === selectedEntryId)
+  const [hovered, setHovered] = useState(false)
+  const [localClipIndex, setLocalClipIndex] = useState(0)
+  const [previewFrames, setPreviewFrames] = useState<Record<string, string>>({})
+  const [versionsExpanded, setVersionsExpanded] = useState(false)
+  const mountedRef = useRef(true)
+  useEffect(() => () => { mountedRef.current = false }, [])
+
+  const viewerPreviewClipIndex = viewerClipName
+    ? findAssetLibraryMotionClipIndex(previewClips.map((clip) => ({ name: clip.clip })), viewerClipName)
+    : -1
+  const clipIndex = viewerEntryId === entry.id && viewerPreviewClipIndex >= 0
+    ? viewerPreviewClipIndex
+    : localClipIndex % Math.max(1, previewClips.length)
+  const activeClip = previewClips[clipIndex]
+  const activeFrameUrl = activeClip ? previewFrames[activeClip.clip] : undefined
+
+  // Gallery motion is the feature, so it begins without requiring a hover.
+  // Compact list rows stay lazy. Every fetched clip is cached per family.
+  useEffect(() => {
+    if ((viewMode !== 'gallery' && !hovered) || !activeClip || previewFrames[activeClip.clip]) return
+    void onFetchPreviewFrame(entry.workspacePath, activeClip.clip).then((dataUrl) => {
+      if (mountedRef.current && dataUrl) {
+        setPreviewFrames((current) => ({ ...current, [activeClip.clip]: dataUrl }))
+      }
+    })
+  }, [viewMode, hovered, activeClip, entry.workspacePath, previewFrames, onFetchPreviewFrame])
+
+  function cycleClip(step: 1 | -1, event: React.MouseEvent | React.KeyboardEvent) {
+    event.preventDefault()
+    event.stopPropagation()
+    if (previewClips.length === 0) return
+    const nextIndex = (clipIndex + step + previewClips.length) % previewClips.length
+    setLocalClipIndex(nextIndex)
+    onSelectViewerClip(entry.id, previewClips[nextIndex].clip)
+  }
 
-      <button
-        type="button"
-        onClick={onOpenSelected}
-        disabled={openDisabled}
-        aria-label="Open selected asset"
-        className="px-3 py-2 bg-violet-600 hover:bg-violet-500 disabled:bg-zinc-700 disabled:text-zinc-500 text-white text-xs rounded-lg transition-colors font-medium"
+  function handleCycleKeyDown(step: 1 | -1, event: React.KeyboardEvent) {
+    if (event.key !== 'Enter' && event.key !== ' ') return
+    cycleClip(step, event)
+  }
+
+  function activateEntry(entryId: string, event?: React.SyntheticEvent) {
+    event?.preventDefault()
+    event?.stopPropagation()
+    if (!disabled) onActivateEntry(entryId)
+  }
+
+  function handleCardKeyDown(event: React.KeyboardEvent<HTMLElement>) {
+    if (event.target !== event.currentTarget || (event.key !== 'Enter' && event.key !== ' ')) return
+    activateEntry(entry.id, event)
+  }
+
+  const displayedThumbnailUrl = activeFrameUrl ?? thumbnailDataUrl
+  const tags = new Set(entry.semantic?.tags ?? [])
+  const badges = [
+    tags.has('animated') ? 'Animated' : null,
+    tags.has('rigged') || entry.capability === 'rigged-mesh' ? 'Rigged' : null,
+    tags.has('character') || tags.has('creature') ? 'Character' : null,
+    tags.has('prop') ? 'Prop' : null,
+    tags.has('low-poly') ? 'Light' : tags.has('mid-poly') ? 'Medium' : tags.has('high-poly') ? 'Heavy' : null,
+    tags.has('unnamed') || !entry.semantic?.name ? 'Needs name' : null,
+  ].filter((badge): badge is string => Boolean(badge))
+  const dateLabel = formatAssetLibraryDate(entry.createdAt)
+
+  const clipControls = activeClip && (
+    <div className={`flex items-center gap-2 ${viewMode === 'gallery'
+      ? 'border-t border-zinc-700/70 bg-zinc-950 px-2 py-2'
+      : 'mt-1'
+    }`}>
+      {previewClips.length > 1 && (
+        <button
+          type="button"
+          aria-label={`Show previous animation for ${family.name}`}
+          onClick={(event) => cycleClip(-1, event)}
+          onKeyDown={(event) => handleCycleKeyDown(-1, event)}
+          className="flex h-6 w-6 shrink-0 items-center justify-center rounded-md bg-zinc-800 text-sm text-zinc-200 hover:bg-zinc-700 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-violet-400"
+        >
+          ‹
+        </button>
+      )}
+      <span className="min-w-0 flex-1 truncate text-center text-[10px] font-medium text-violet-200">
+        {viewMode === 'gallery' ? 'Animation: ' : ''}{formatAssetLibraryClipName(activeClip.clip)}
+      </span>
+      <span className="shrink-0 text-[9px] text-zinc-500">{clipIndex + 1}/{previewClips.length}</span>
+      {previewClips.length > 1 && (
+        <button
+          type="button"
+          aria-label={`Show next animation for ${family.name}`}
+          onClick={(event) => cycleClip(1, event)}
+          onKeyDown={(event) => handleCycleKeyDown(1, event)}
+          className="flex h-6 w-6 shrink-0 items-center justify-center rounded-md bg-zinc-800 text-sm text-zinc-200 hover:bg-zinc-700 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-violet-400"
+        >
+          ›
+        </button>
+      )}
+    </div>
+  )
+
+  if (viewMode === 'list') {
+    return (
+      <article
+        role="listitem"
+        tabIndex={disabled ? -1 : 0}
+        aria-disabled={disabled}
+        aria-label={`Open asset family ${family.name}`}
+        onClick={() => activateEntry(entry.id)}
+        onKeyDown={handleCardKeyDown}
+        onMouseEnter={() => setHovered(true)}
+        onMouseLeave={() => setHovered(false)}
+        className={`cursor-pointer px-3 py-2 transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-violet-400 ${
+          selected ? 'bg-violet-500/10' : 'hover:bg-zinc-800/70'
+        } ${disabled ? 'pointer-events-none opacity-50' : ''}`}
       >
-        {opening ? 'Opening…' : 'Open selected asset'}
-      </button>
+        <div className="flex flex-wrap items-center gap-3">
+          <div className="relative h-14 w-14 shrink-0 overflow-hidden rounded-lg border border-zinc-700 bg-zinc-950">
+            {displayedThumbnailUrl ? (
+              <img src={displayedThumbnailUrl} alt="" className="h-full w-full object-contain" />
+            ) : (
+              <AssetLibraryPreviewPlaceholder />
+            )}
+          </div>
+          <div className="min-w-[12rem] flex-1">
+            <div className="flex items-center gap-2">
+              <span className="truncate text-xs font-medium text-zinc-200">{family.name}</span>
+              {family.entries.length > 1 && (
+                <span className="shrink-0 rounded-full bg-violet-500/15 px-2 py-0.5 text-[9px] text-violet-200">{family.entries.length} versions</span>
+              )}
+            </div>
+            <div className="mt-1 flex flex-wrap gap-1">
+              {badges.slice(0, 4).map((badge) => (
+                <span key={badge} className={`rounded-full px-1.5 py-0.5 text-[8px] ${
+                  badge === 'Needs name' ? 'bg-amber-500/15 text-amber-200' : 'bg-zinc-800 text-zinc-400'
+                }`}>{badge}</span>
+              ))}
+            </div>
+            <p className="mt-1 truncate text-[9px] text-zinc-500" title={entry.workspacePath}>{entry.workspacePath}</p>
+          </div>
+          <div className="w-40 max-w-full shrink-0">{clipControls}</div>
+          <span className="w-16 shrink-0 text-right text-[9px] text-zinc-500">{dateLabel}</span>
+          {family.entries.length > 1 && (
+            <button
+              type="button"
+              aria-expanded={versionsExpanded}
+              onClick={(event) => {
+                event.preventDefault()
+                event.stopPropagation()
+                setVersionsExpanded((current) => !current)
+              }}
+              className="shrink-0 rounded-md bg-zinc-800 px-2 py-1 text-[9px] text-zinc-300 hover:bg-zinc-700"
+            >
+              {versionsExpanded ? 'Hide versions' : 'Show versions'}
+            </button>
+          )}
+        </div>
+        {versionsExpanded && <AssetLibraryVersionRows family={family} selectedEntryId={selectedEntryId} onActivateEntry={activateEntry} />}
+      </article>
+    )
+  }
+
+  return (
+    <article
+      role="listitem"
+      tabIndex={disabled ? -1 : 0}
+      aria-disabled={disabled}
+      aria-label={`Open asset family ${family.name}`}
+      onClick={() => activateEntry(entry.id)}
+      onKeyDown={handleCardKeyDown}
+      onMouseEnter={() => setHovered(true)}
+      onMouseLeave={() => setHovered(false)}
+      className={`min-w-0 cursor-pointer overflow-hidden rounded-xl border bg-zinc-900 transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-violet-400 ${
+        selected ? 'border-violet-400/70 bg-violet-500/10' : 'border-zinc-700/80 hover:border-zinc-600'
+      } ${disabled ? 'pointer-events-none opacity-50' : ''}`}
+    >
+      <div className="relative h-40 w-full overflow-hidden bg-zinc-950">
+        {displayedThumbnailUrl ? (
+          <img
+            src={displayedThumbnailUrl}
+            alt=""
+            className="h-full w-full object-contain"
+          />
+        ) : (
+          <AssetLibraryPreviewPlaceholder />
+        )}
+        {activeFrameUrl && (
+          <span className="absolute left-2 top-2 rounded-full border border-violet-300/30 bg-violet-950/80 px-2 py-1 text-[9px] font-medium text-violet-100">
+            Playing
+          </span>
+        )}
+        {family.entries.length > 1 && (
+          <span className="absolute right-2 top-2 rounded-full border border-zinc-600 bg-black/75 px-2 py-1 text-[9px] font-medium text-zinc-100">
+            {family.entries.length} versions
+          </span>
+        )}
+      </div>
+      {clipControls}
+      <div className="p-3">
+        <div className="flex items-start justify-between gap-2">
+          <h3 className="min-w-0 truncate text-xs font-semibold text-zinc-100">{family.name}</h3>
+          <span className="shrink-0 text-[9px] text-zinc-500">{dateLabel}</span>
+        </div>
+        <div className="mt-2 flex min-h-5 flex-wrap gap-1">
+          {badges.slice(0, 4).map((badge) => (
+            <span key={badge} className={`rounded-full px-2 py-0.5 text-[9px] ${
+              badge === 'Needs name' ? 'bg-amber-500/15 text-amber-200' : 'bg-zinc-800 text-zinc-300'
+            }`}>{badge}</span>
+          ))}
+        </div>
+        <p className="mt-2 truncate border-t border-zinc-800 pt-2 text-[9px] text-zinc-500" title={entry.workspacePath}>
+          Stored at {entry.workspacePath}
+        </p>
+        {family.entries.length > 1 && (
+          <button
+            type="button"
+            aria-expanded={versionsExpanded}
+            onClick={(event) => {
+              event.preventDefault()
+              event.stopPropagation()
+              setVersionsExpanded((current) => !current)
+            }}
+            className="mt-2 w-full rounded-lg border border-violet-400/20 bg-violet-500/10 px-2 py-1.5 text-[10px] font-medium text-violet-200 hover:bg-violet-500/20"
+          >
+            {versionsExpanded ? 'Hide version family' : `Show all ${family.entries.length} versions`}
+          </button>
+        )}
+      </div>
+      {versionsExpanded && <AssetLibraryVersionRows family={family} selectedEntryId={selectedEntryId} onActivateEntry={activateEntry} />}
+    </article>
+  )
+}
+
+function AssetLibraryVersionRows({
+  family,
+  selectedEntryId,
+  onActivateEntry,
+}: {
+  family: AssetLibraryLineageFamily
+  selectedEntryId: string | null
+  onActivateEntry: (entryId: string, event?: React.SyntheticEvent) => void
+}) {
+  return (
+    <div className="border-t border-zinc-700 bg-zinc-950/70 p-2">
+      <p className="px-1 pb-1.5 text-[9px] font-medium uppercase tracking-wider text-zinc-500">Version family</p>
+      <div className="space-y-1">
+        {family.entries.map((entry, index) => (
+          <button
+            key={entry.id}
+            type="button"
+            onClick={(event) => onActivateEntry(entry.id, event)}
+            className={`flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left hover:bg-zinc-800 ${
+              entry.id === selectedEntryId ? 'bg-violet-500/15' : ''
+            }`}
+          >
+            <span className="w-11 shrink-0 text-[9px] font-medium text-zinc-300">{index === 0 ? 'Latest' : `Older ${index}`}</span>
+            <span className="min-w-0 flex-1 truncate text-[9px] text-zinc-400" title={entry.workspacePath}>{entry.workspacePath}</span>
+            <span className="shrink-0 text-[8px] text-zinc-600">{formatAssetLibraryDate(entry.createdAt)}</span>
+          </button>
+        ))}
+      </div>
+    </div>
+  )
+}
+
+function AssetLibraryPreviewPlaceholder() {
+  return (
+    <div className="flex h-full w-full items-center justify-center text-zinc-700" aria-hidden="true">
+      <svg width="36" height="36" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.2">
+        <path d="m12 2 8 4.5v9L12 20l-8-4.5v-9L12 2Z" />
+        <path d="m4 6.5 8 4.5 8-4.5M12 11v9" />
+      </svg>
     </div>
   )
 }
 
+function formatAssetLibraryDate(value: string | undefined): string {
+  if (!value) return 'Unknown date'
+  const date = new Date(value)
+  if (!Number.isFinite(date.getTime())) return 'Unknown date'
+  return date.toLocaleDateString(undefined, { month: 'short', day: 'numeric' })
+}
+
 // ---------------------------------------------------------------------------
 // GeneratePage
 // ---------------------------------------------------------------------------
 
 export default function GeneratePage(): JSX.Element {
   const [unloadStatus, setUnloadStatus] = useState<'idle' | 'done'>('idle')
-  const [panelWidth, setPanelWidth] = useState(DEFAULT_WIDTH)
+  const [panelWidth, setPanelWidth] = useState<number>(() => getStoredPanelWidth())
   const [openPanel, setOpenPanel] = useState<GenerateOpenPanel>(null)
   const [decimating, setDecimating] = useState(false)
   const [smoothing, setSmoothing] = useState(false)
@@ -573,10 +1060,19 @@ export default function GeneratePage(): JSX.Element {
   const [libraryOpening, setLibraryOpening] = useState(false)
   const [libraryError, setLibraryError] = useState<string | null>(null)
   const [librarySearchQuery, setLibrarySearchQuery] = useState('')
-  const [librarySortMode, setLibrarySortMode] = useState<AssetLibrarySortMode>('type')
+  const [librarySortMode, setLibrarySortMode] = useState<AssetLibrarySortMode>('date')
+  const [libraryViewMode, setLibraryViewMode] = useState<AssetLibraryViewMode>('gallery')
+  const [libraryFilters, setLibraryFilters] = useState<AssetLibraryFilters>(() => createDefaultAssetLibraryFilters())
   const [libraryCollapsedSectionKeys, setLibraryCollapsedSectionKeys] = useState<string[]>(() => getDefaultAssetLibraryCollapsedSectionKeys())
+  const [libraryThumbnails, setLibraryThumbnails] = useState<Record<string, string>>({})
+  const [libraryPreviews, setLibraryPreviews] = useState<Record<string, AssetLibraryPreviewClip[]>>({})
+  const [libraryPanelWidth, setLibraryPanelWidth] = useState<number>(() => getStoredAssetLibraryPanelWidth())
+  const [libraryPanelHeight, setLibraryPanelHeight] = useState<number>(() => getStoredAssetLibraryPanelHeight())
   const [gizmoMode, setGizmoMode] = useState<'translate' | 'rotate' | 'scale' | null>(null)
   const dragging = useRef(false)
+  const libraryPanelDragging = useRef(false)
+  const libraryPanelHeightDragging = useRef(false)
+  const libraryAnchorRef = useRef<HTMLDivElement | null>(null)
   // Populated by Viewer3D — undoes the latest live gizmo transform, if any.
   const gizmoUndoRef = useRef<(() => boolean) | null>(null)
 
@@ -592,6 +1088,9 @@ export default function GeneratePage(): JSX.Element {
   const setCurrentJob = useAppStore((s) => s.setCurrentJob)
   const meshStats = useAppStore((s) => s.meshStats)
   const meshSelected = useAppStore((s) => s.meshSelected)
+  const motionClips = useAppStore((s) => s.motionClips)
+  const activeClipIndex = useAppStore((s) => s.activeClipIndex)
+  const setActiveClipIndex = useAppStore((s) => s.setActiveClipIndex)
   const pushMeshUrl = useAppStore((s) => s.pushMeshUrl)
   const undoMesh = useAppStore((s) => s.undoMesh)
   const redoMesh = useAppStore((s) => s.redoMesh)
@@ -599,6 +1098,7 @@ export default function GeneratePage(): JSX.Element {
   const canRedo = useAppStore((s) => s.historyIndex < s.meshHistory.length - 1)
   const { optimizeMesh, smoothMesh, importMesh } = useApi()
   const assetLibraryService = useMemo(() => getDefaultAssetLibraryService(), [])
+  const viewerClipName = motionClips[activeClipIndex]?.name ?? null
 
   useEffect(() => {
     const handler = (e: KeyboardEvent) => {
@@ -640,6 +1140,21 @@ export default function GeneratePage(): JSX.Element {
     // eslint-disable-next-line react-hooks/exhaustive-deps -- lazy-load guarded by loaded/loading flags
   }, [openPanel, libraryLoaded, libraryLoading])
 
+  // Persist the library panel's width so a manual resize survives app restarts.
+  useEffect(() => {
+    storeAssetLibraryPanelWidth(libraryPanelWidth)
+  }, [libraryPanelWidth])
+
+  // Persist the library panel's height so a manual resize survives app restarts.
+  useEffect(() => {
+    storeAssetLibraryPanelHeight(libraryPanelHeight)
+  }, [libraryPanelHeight])
+
+  // Persist the generate options panel's width so a manual resize survives app restarts.
+  useEffect(() => {
+    storePanelWidth(panelWidth)
+  }, [panelWidth])
+
   async function handleUnloadAll() {
     await window.electron.model.unloadAll()
     setUnloadStatus('done')
@@ -705,11 +1220,20 @@ export default function GeneratePage(): JSX.Element {
         setLibraryError(result.error.message)
         return
       }
+      const defaultPrimaryEntry = buildAssetLibraryProjectGroups(
+        result.entries,
+        '',
+        'date',
+        createDefaultAssetLibraryFilters(),
+      )
+        .flatMap((group) => group.families.map((family) => family.primaryEntry))
+        .find(isAssetLibraryEntryOpenable)
       setLibraryEntries(result.entries)
       setLibrarySelectedEntryId((current) => current && result.entries.some((entry) => entry.id === current)
         ? current
-        : result.entries.find(isAssetLibraryEntryOpenable)?.id ?? result.entries[0]?.id ?? null)
+        : defaultPrimaryEntry?.id ?? result.entries.find(isAssetLibraryEntryOpenable)?.id ?? result.entries[0]?.id ?? null)
       setLibraryLoaded(true)
+      void loadLibraryThumbnails(result.entries)
     } catch (err) {
       setLibraryLoaded(false)
       setLibraryEntries([])
@@ -720,21 +1244,60 @@ export default function GeneratePage(): JSX.Element {
     }
   }
 
-  async function handleOpenSelectedLibraryEntry() {
-    const selectedEntry = libraryEntries.find((entry) => entry.id === librarySelectedEntryId) ?? null
-    if (!selectedEntry) {
+  // Thumbnails are best-effort: only .glb/.gltf entries can have a rendered
+  // .thumb.png, and a missing one is silently skipped rather than surfaced.
+  // The same request also carries preview clip metadata when a preview
+  // manifest exists for that asset — most entries won't have one yet, and
+  // those are simply absent from libraryPreviews.
+  async function loadLibraryThumbnails(entries: ProjectedAssetLibraryEntry[]) {
+    type ThumbnailFetchResult = { workspacePath: string, dataUrl: string | null, previews: AssetLibraryPreviewClip[] }
+    const candidates = entries.filter((entry) => entry.previewKind === '3d-model')
+    const results: ThumbnailFetchResult[] = await Promise.all(candidates.map(async (entry) => {
+      const result = await assetLibraryService.thumbnail({ workspacePath: entry.workspacePath })
+      return {
+        workspacePath: entry.workspacePath,
+        dataUrl: result.success ? result.dataUrl : null,
+        previews: result.success ? result.previews ?? [] : [],
+      }
+    }))
+    setLibraryThumbnails(Object.fromEntries(
+      results
+        .filter((result): result is ThumbnailFetchResult & { dataUrl: string } => result.dataUrl !== null)
+        .map((result) => [result.workspacePath, result.dataUrl]),
+    ))
+    setLibraryPreviews(Object.fromEntries(
+      results.filter((result) => result.previews.length > 0).map((result) => [result.workspacePath, result.previews]),
+    ))
+  }
+
+  // Fetches one looping preview clip's WebP, lazily, over the same thumbnail
+  // IPC call the static thumbnails use. A miss (clip removed, file unreadable)
+  // resolves to null rather than throwing, so a row can just keep its static
+  // thumbnail.
+  const fetchLibraryPreviewFrame = useCallback(async (workspacePath: string, clip: string): Promise<string | null> => {
+    try {
+      const result = await assetLibraryService.thumbnail({ workspacePath, previewClip: clip })
+      return result.success ? result.dataUrl : null
+    } catch {
+      return null
+    }
+  }, [assetLibraryService])
+
+  // A Library row opens through this shared validation and import path.
+  async function openLibraryEntry(entry: ProjectedAssetLibraryEntry | null) {
+    if (!entry) {
       setLibraryError('Select an asset before opening it in Generate.')
       return
     }
-    if (!isAssetLibraryEntryOpenable(selectedEntry)) {
-      setLibraryError(describeAssetLibraryOpenability(selectedEntry))
+    if (!isAssetLibraryEntryOpenable(entry)) {
+      setLibraryError(describeAssetLibraryOpenability(entry))
       return
     }
 
     setLibraryOpening(true)
     setLibraryError(null)
     try {
-      const result = await assetLibraryService.open(buildAssetLibraryOpenRequest(selectedEntry))
+      const result = await assetLibraryService.open(buildAssetLibraryOpenRequest(entry))
       if (!result.success) {
         setLibraryError(result.error.message)
         return
@@ -745,7 +1308,7 @@ export default function GeneratePage(): JSX.Element {
         setLibraryError(describeAssetLibraryOpenability(result.entry))
         return
       }
-      setLibraryEntries((currentEntries) => currentEntries.map((entry) => entry.id === result.entry.id ? result.entry : entry))
+      setLibraryEntries((currentEntries) => currentEntries.map((candidate) => candidate.id === result.entry.id ? result.entry : candidate))
       setLibrarySelectedEntryId(result.entry.id)
       setCurrentJob(selection.job)
       pushMeshUrl(selection.historyUrl)
@@ -757,6 +1320,21 @@ export default function GeneratePage(): JSX.Element {
     }
   }
 
+  // A single click on a row both selects and opens it. Non-openable entries
+  // stay selected and surface their reason in the conditional message above.
+  async function handleActivateLibraryEntry(entryId: string) {
+    setLibraryError(null)
+    setLibrarySelectedEntryId(entryId)
+    const entry = libraryEntries.find((candidate) => candidate.id === entryId) ?? null
+    await openLibraryEntry(entry)
+  }
+
+  function handleSelectLibraryViewerClip(entryId: string, clip: string) {
+    if (currentJob?.libraryEntryId !== entryId) return
+    const viewerIndex = findAssetLibraryMotionClipIndex(motionClips, clip)
+    if (viewerIndex >= 0) setActiveClipIndex(viewerIndex)
+  }
+
   async function handleSmooth(iterations: number) {
     if (!currentJob?.outputUrl) return
     setSmoothing(true)
@@ -795,7 +1373,7 @@ export default function GeneratePage(): JSX.Element {
 
     const onMouseMove = (ev: MouseEvent) => {
       if (!dragging.current) return
-      setPanelWidth((w) => Math.min(MAX_WIDTH, Math.max(MIN_WIDTH, w + ev.movementX)))
+      setPanelWidth((w) => clampPanelWidth(w + ev.movementX))
     }
     const onMouseUp = () => {
       dragging.current = false
@@ -806,16 +1384,54 @@ export default function GeneratePage(): JSX.Element {
     window.addEventListener('mouseup', onMouseUp)
   }, [])
 
+  const onLibraryPanelResizeMouseDown = useCallback((e: React.MouseEvent) => {
+    e.preventDefault()
+    libraryPanelDragging.current = true
+
+    const onMouseMove = (ev: MouseEvent) => {
+      if (!libraryPanelDragging.current) return
+      setLibraryPanelWidth((w) => clampAssetLibraryPanelWidth(w + ev.movementX))
+    }
+    const onMouseUp = () => {
+      libraryPanelDragging.current = false
+      window.removeEventListener('mousemove', onMouseMove)
+      window.removeEventListener('mouseup', onMouseUp)
+    }
+    window.addEventListener('mousemove', onMouseMove)
+    window.addEventListener('mouseup', onMouseUp)
+  }, [])
+
+  const onLibraryPanelResizeHeightMouseDown = useCallback((e: React.MouseEvent) => {
+    e.preventDefault()
+    libraryPanelHeightDragging.current = true
+
+    const onMouseMove = (ev: MouseEvent) => {
+      if (!libraryPanelHeightDragging.current) return
+      setLibraryPanelHeight((h) => clampAssetLibraryPanelHeight(h + ev.movementY))
+    }
+    const onMouseUp = () => {
+      libraryPanelHeightDragging.current = false
+      window.removeEventListener('mousemove', onMouseMove)
+      window.removeEventListener('mouseup', onMouseUp)
+    }
+    window.addEventListener('mousemove', onMouseMove)
+    window.addEventListener('mouseup', onMouseUp)
+  }, [])
+
   return (
     <>
       <div className="flex flex-col border-r border-zinc-800 bg-surface-400 overflow-hidden shrink-0" style={{ width: panelWidth }}>
         <WorkflowPanel />
       </div>
 
-      {/* Resize handle */}
+      {/* Resize handle — drag to widen/narrow the generate options panel; size is persisted. */}
       <div
         onMouseDown={onMouseDown}
-        className="w-1 shrink-0 cursor-col-resize hover:bg-accent/40 active:bg-accent/60 transition-colors"
+        role="separator"
+        aria-orientation="vertical"
+        aria-label="Resize the generate options panel"
+        title="Drag to make this panel wider or narrower"
+        className="w-2 shrink-0 cursor-col-resize bg-zinc-600/40 hover:bg-accent/60 active:bg-accent/70 transition-colors"
       />
 
       <div className="flex-1 flex flex-col overflow-hidden">
@@ -910,7 +1526,7 @@ export default function GeneratePage(): JSX.Element {
             )}
           </div>
 
-          <div className="relative">
+          <div ref={libraryAnchorRef} className="relative">
             <AssetLibraryToggleButton
               open={openPanel === 'library'}
               disabled={importing || libraryOpening}
@@ -928,17 +1544,28 @@ export default function GeneratePage(): JSX.Element {
                 error={libraryError}
                 searchQuery={librarySearchQuery}
                 sortMode={librarySortMode}
+                viewMode={libraryViewMode}
+                filters={libraryFilters}
                 collapsedSectionKeys={libraryCollapsedSectionKeys}
-                onSelectEntry={(entryId) => {
-                  setLibraryError(null)
-                  setLibrarySelectedEntryId(entryId)
-                }}
+                thumbnails={libraryThumbnails}
+                previews={libraryPreviews}
+                panelWidth={libraryPanelWidth}
+                panelHeight={libraryPanelHeight}
+                anchorRef={libraryAnchorRef}
+                viewerEntryId={currentJob?.libraryEntryId ?? null}
+                viewerClipName={viewerClipName}
+                onActivateEntry={(entryId) => { void handleActivateLibraryEntry(entryId) }}
+                onSelectViewerClip={handleSelectLibraryViewerClip}
                 onSearchQueryChange={setLibrarySearchQuery}
                 onSortModeChange={setLibrarySortMode}
+                onViewModeChange={setLibraryViewMode}
+                onFiltersChange={setLibraryFilters}
                 onToggleSection={(sectionKey) => setLibraryCollapsedSectionKeys((current) => toggleAssetLibrarySectionKey(current, sectionKey))}
-                onOpenSelected={() => { void handleOpenSelectedLibraryEntry() }}
+                onFetchPreviewFrame={fetchLibraryPreviewFrame}
                 onRefresh={() => { void loadLibraryEntries() }}
                 onClose={() => setOpenPanel(null)}
+                onResizeMouseDown={onLibraryPanelResizeMouseDown}
+                onResizeHeightMouseDown={onLibraryPanelResizeHeightMouseDown}
               />
             )}
           </div>
@@ -1130,4 +1757,4 @@ export default function GeneratePage(): JSX.Element {
       </div>
     </>
   )
-}
\ No newline at end of file
+}
diff --git a/src/areas/generate/assetLibraryProjection.ts b/src/areas/generate/assetLibraryProjection.ts
index b65f5b50..1a6369d3 100644
--- a/src/areas/generate/assetLibraryProjection.ts
+++ b/src/areas/generate/assetLibraryProjection.ts
@@ -21,7 +21,7 @@ export interface AssetLibraryScopeGroup {
 
 function isSafeWorkspacePath(workspacePath: string): boolean {
   const normalized = workspacePath.replace(/\\/g, '/').trim()
-  return /^(Workflows|Exports)\//.test(normalized)
+  return /^(Default|Workflows|Exports)\//.test(normalized)
     && !normalized.split('/').includes('..')
     && !/%2e|%2f|%5c/i.test(normalized)
     && !normalized.startsWith('/')
@@ -40,9 +40,22 @@ export function projectAssetLibraryEntry(entry: AssetLibraryEntry): ProjectedAss
   }
   const safeSource = entry.source && isSafeWorkspacePath(entry.source.workspacePath) ? entry.source : undefined
   const safeManifest = entry.manifest && isSafeWorkspacePath(entry.manifest.workspacePath) ? entry.manifest : undefined
+  const safeParent = entry.semantic?.derivedFrom?.parent && isSafeWorkspacePath(entry.semantic.derivedFrom.parent.workspacePath)
+    ? entry.semantic.derivedFrom.parent
+    : undefined
+  const safeRoot = entry.semantic?.derivedFrom?.root && isSafeWorkspacePath(entry.semantic.derivedFrom.root.workspacePath)
+    ? entry.semantic.derivedFrom.root
+    : undefined
   if (entry.source && !safeSource) warnings.push('Ignored unsafe source workspace path.')
   if (entry.manifest && !safeManifest) warnings.push('Ignored unsafe manifest workspace path.')
-  return { ...entry, source: safeSource, manifest: safeManifest, warnings: [...new Set(warnings)] }
+  if (entry.semantic?.derivedFrom && (!safeParent || !safeRoot)) warnings.push('Ignored unsafe asset lineage.')
+  const semantic = entry.semantic
+    ? {
+        ...entry.semantic,
+        derivedFrom: safeParent && safeRoot ? { parent: safeParent, root: safeRoot } : undefined,
+      }
+    : undefined
+  return { ...entry, source: safeSource, manifest: safeManifest, semantic, warnings: [...new Set(warnings)] }
 }
 
 export function resolveAssetLibraryOpenTarget(entry: ProjectedAssetLibraryEntry): AssetLibraryOpenTarget {
@@ -80,6 +93,11 @@ export function filterAssetLibraryEntries(entries: ProjectedAssetLibraryEntry[],
     entry.state,
     entry.source?.workspacePath ?? '',
     entry.manifest?.workspacePath ?? '',
+    entry.semantic?.name ?? '',
+    entry.semantic?.project ?? '',
+    ...(entry.semantic?.tags ?? []),
+    entry.semantic?.derivedFrom?.parent.workspacePath ?? '',
+    entry.semantic?.derivedFrom?.root.workspacePath ?? '',
   ].some((value) => value.toLowerCase().includes(needle)))
 }
 
diff --git a/src/areas/generate/assetLibraryService.test.ts b/src/areas/generate/assetLibraryService.test.ts
index 9e7938c4..6a2bda1c 100644
--- a/src/areas/generate/assetLibraryService.test.ts
+++ b/src/areas/generate/assetLibraryService.test.ts
@@ -50,6 +50,7 @@ test('renderer service delegates safe IPC calls and normalizes returned entries'
     }),
     read: async () => ({ success: false, error: { code: 'missing', message: 'Missing' } }),
     open: async (request) => { openRequest = request; return { success: false, error: { code: 'missing', message: 'Missing' } } },
+    thumbnail: async () => ({ success: false }),
   })
 
   const result = await service.list()
@@ -58,3 +59,38 @@ test('renderer service delegates safe IPC calls and normalizes returned entries'
   await service.open({ workspacePath: 'Workflows/hero.landmarks.v1.json', sourceWorkspacePath: 'Workflows/hero.glb' })
   assert.deepEqual(openRequest, { workspacePath: 'Workflows/hero.landmarks.v1.json', sourceWorkspacePath: 'Workflows/hero.glb' })
 })
+
+test('renderer service validates thumbnail requests before IPC and never surfaces an error', async () => {
+  let invoked = false
+  const service = createAssetLibraryService({
+    list: async () => ({ success: true, entries: [] }),
+    read: async () => ({ success: false, error: { code: 'unexpected', message: 'should not run' } }),
+    open: async () => ({ success: false, error: { code: 'unexpected', message: 'should not run' } }),
+    thumbnail: async () => { invoked = true; return { success: true, dataUrl: 'data:image/png;base64,ok' } },
+  })
+
+  const unsafe = await service.thumbnail({ workspacePath: '../escape.glb' })
+  assert.deepEqual(unsafe, { success: false })
+  assert.equal(invoked, false)
+
+  const safe = await service.thumbnail({ workspacePath: 'Exports/hero.glb' })
+  assert.deepEqual(safe, { success: true, dataUrl: 'data:image/png;base64,ok' })
+  assert.equal(invoked, true)
+})
+
+test('renderer service forwards previewClip through to the thumbnail IPC call unchanged', async () => {
+  let receivedRequest: unknown = null
+  const service = createAssetLibraryService({
+    list: async () => ({ success: true, entries: [] }),
+    read: async () => ({ success: false, error: { code: 'read-failed', message: 'should not run' } }),
+    open: async () => ({ success: false, error: { code: 'read-failed', message: 'should not run' } }),
+    thumbnail: async (request) => {
+      receivedRequest = request
+      return { success: true, dataUrl: 'data:image/webp;base64,ok', previews: [{ clip: 'walk', duration: 0.8 }] }
+    },
+  })
+
+  const result = await service.thumbnail({ workspacePath: 'Exports/hero.glb', previewClip: 'walk' })
+  assert.deepEqual(receivedRequest, { workspacePath: 'Exports/hero.glb', previewClip: 'walk' })
+  assert.deepEqual(result, { success: true, dataUrl: 'data:image/webp;base64,ok', previews: [{ clip: 'walk', duration: 0.8 }] })
+})
diff --git a/src/areas/generate/assetLibraryService.ts b/src/areas/generate/assetLibraryService.ts
index 38738579..5c18d49d 100644
--- a/src/areas/generate/assetLibraryService.ts
+++ b/src/areas/generate/assetLibraryService.ts
@@ -5,6 +5,8 @@ import type {
   AssetLibraryOpenResult,
   AssetLibraryReadRequest,
   AssetLibraryReadResult,
+  AssetLibraryThumbnailRequest,
+  AssetLibraryThumbnailResult,
 } from '../../shared/types/assetLibrary'
 import { projectAssetLibraryEntry, type ProjectedAssetLibraryEntry } from './assetLibraryProjection'
 
@@ -12,6 +14,7 @@ export interface AssetLibraryPreloadApi {
   list: () => Promise<AssetLibraryListResult>
   read: (request: AssetLibraryReadRequest) => Promise<AssetLibraryReadResult>
   open: (request: AssetLibraryOpenRequest) => Promise<AssetLibraryOpenResult>
+  thumbnail: (request: AssetLibraryThumbnailRequest) => Promise<AssetLibraryThumbnailResult>
 }
 
 export type ProjectedAssetLibraryListResult =
@@ -60,6 +63,12 @@ export function createAssetLibraryService(api: AssetLibraryPreloadApi) {
       if (!result.success) return result
       return { success: true, entry: projectAssetLibraryEntry(result.entry) }
     },
+    // A missing/invalid thumbnail is never an error the UI needs to show — the
+    // Library list just falls back to its text-only row.
+    async thumbnail(request: AssetLibraryThumbnailRequest): Promise<AssetLibraryThumbnailResult> {
+      if (validateWorkspacePath(request.workspacePath)) return { success: false }
+      return api.thumbnail(request)
+    },
   }
 }
 
diff --git a/src/areas/generate/assetLibraryUi.test.ts b/src/areas/generate/assetLibraryUi.test.ts
index e6b9fbca..db433b1e 100644
--- a/src/areas/generate/assetLibraryUi.test.ts
+++ b/src/areas/generate/assetLibraryUi.test.ts
@@ -3,13 +3,25 @@ import test from 'node:test'
 
 import {
   buildAssetLibraryOpenRequest,
+  buildAssetLibraryProjectGroups,
+  clampAssetLibraryPanelHeight,
+  clampAssetLibraryPanelWidth,
   createAssetLibraryOpenJob,
+  createDefaultAssetLibraryFilters,
   describeAssetLibraryOpenability,
-  filterAssetLibraryScopeGroups,
+  findAssetLibraryMotionClipIndex,
+  formatAssetLibraryClipName,
+  getAssetLibraryPanelLayout,
   getDefaultAssetLibraryCollapsedSectionKeys,
+  getStoredAssetLibraryPanelHeight,
+  getStoredAssetLibraryPanelWidth,
   isAssetLibraryEntryOpenable,
+  isAssetLibrarySectionExpanded,
   resolveOpenPanelAfterLibrarySelection,
+  storeAssetLibraryPanelHeight,
+  storeAssetLibraryPanelWidth,
   toggleAssetLibrarySectionKey,
+  type AssetLibraryFilters,
   type AssetLibrarySortMode,
   type GenerateOpenPanel,
 } from './assetLibraryUi.ts'
@@ -18,83 +30,138 @@ import type { AssetLibraryEntry } from '../../shared/types/assetLibrary.ts'
 
 function entry(overrides: Partial<AssetLibraryEntry> = {}): ProjectedAssetLibraryEntry {
   const base: AssetLibraryEntry = {
-    id: 'library:Workflows/hero.glb',
-    workspacePath: 'Workflows/hero.glb',
+    id: 'library:Default/hero.glb',
+    workspacePath: 'Default/hero.glb',
     displayName: 'hero.glb',
-    sourceScope: 'workflows',
+    sourceScope: 'generated',
     capability: 'mesh',
     state: 'ready',
     previewKind: '3d-model',
     warnings: [],
     openable: true,
     createdAt: '2026-06-16T10:00:00.000Z',
+    semantic: { name: 'Hero', tags: ['mid-poly'] },
     ...overrides,
   }
   return projectAssetLibraryEntry(base)
 }
 
-function groupPaths(entries: ProjectedAssetLibraryEntry[], search = '', sortMode: AssetLibrarySortMode = 'type'): string[] {
-  return filterAssetLibraryScopeGroups(entries, search, sortMode).flatMap((scopeGroup) => (
-    scopeGroup.entryGroups.flatMap((group) => group.entries.map((item) => item.workspacePath))
-  ))
+const root = entry({
+  id: 'root',
+  workspacePath: 'Default/hero.glb',
+  displayName: 'Hero',
+  createdAt: '2026-06-15T10:00:00.000Z',
+  semantic: { name: 'Hero', tags: ['mid-poly'] },
+})
+
+const derived = entry({
+  id: 'derived',
+  workspacePath: 'Exports/adventure/hero-rigged.glb',
+  displayName: 'Hero Rigged',
+  sourceScope: 'exports',
+  capability: 'rigged-mesh',
+  createdAt: '2026-06-18T10:00:00.000Z',
+  semantic: {
+    name: 'Hero Rigged',
+    project: 'Adventure',
+    tags: ['rigged', 'animated', 'character', 'mid-poly', 'clip-hero-walk'],
+    derivedFrom: {
+      parent: { workspacePath: 'Default/hero.glb', displayName: 'Hero' },
+      root: { workspacePath: 'Default/hero.glb', displayName: 'Hero' },
+    },
+  },
+})
+
+const prop = entry({
+  id: 'prop',
+  workspacePath: 'Exports/props/chair.glb',
+  displayName: 'Chair',
+  sourceScope: 'exports',
+  createdAt: '2026-06-17T10:00:00.000Z',
+  semantic: { name: 'Chair', project: 'Props', tags: ['prop', 'low-poly', 'textured'] },
+})
+
+const unnamed = entry({
+  id: 'unnamed',
+  workspacePath: 'Workflows/run/1785_abcd.glb',
+  displayName: '1785_abcd.glb',
+  sourceScope: 'workflows',
+  createdAt: '2026-06-19T10:00:00.000Z',
+  semantic: { tags: ['unnamed', 'high-poly'] },
+})
+
+function groups(
+  entries: ProjectedAssetLibraryEntry[],
+  search = '',
+  sortMode: AssetLibrarySortMode = 'date',
+  filters: AssetLibraryFilters = createDefaultAssetLibraryFilters(),
+) {
+  return buildAssetLibraryProjectGroups(entries, search, sortMode, filters)
 }
 
-test('organizes visible library assets by scope and capability with collapsible section keys', () => {
-  const entries = [
-    entry({ id: 'workflow-mesh', workspacePath: 'Workflows/run/hero.glb', displayName: 'hero.glb', sourceScope: 'workflows', capability: 'mesh' }),
-    entry({ id: 'export-rig', workspacePath: 'Exports/rig/hero-rig.gltf', displayName: 'hero-rig.gltf', sourceScope: 'exports', capability: 'rigged-mesh' }),
-    entry({ id: 'hidden-cache', workspacePath: 'Workflows/run/cache/internal.glb', displayName: 'internal.glb', sourceScope: 'workflows' }),
-    entry({ id: 'unsupported', workspacePath: 'Exports/readme.txt', displayName: 'readme.txt', sourceScope: 'exports', state: 'unsupported', openable: false }),
-  ]
-
-  const groups = filterAssetLibraryScopeGroups(entries, '', 'type')
-  assert.deepEqual(groups.map((group) => [group.sourceScope, group.entryGroups.map((entryGroup) => entryGroup.capability)]), [
-    ['workflows', ['mesh']],
-    ['exports', ['rigged-mesh']],
-  ])
-  assert.deepEqual(groupPaths(entries), ['Workflows/run/hero.glb', 'Exports/rig/hero-rig.gltf'])
-  assert.equal(getDefaultAssetLibraryCollapsedSectionKeys().includes('scope:workflows'), true)
-  assert.deepEqual(toggleAssetLibrarySectionKey(['scope:workflows'], 'scope:workflows'), [])
-  assert.deepEqual(toggleAssetLibrarySectionKey([], 'scope:exports'), ['scope:exports'])
+test('groups by project and collapses every version that shares a lineage root', () => {
+  const result = groups([root, derived, prop, unnamed])
+
+  assert.deepEqual(result.map((group) => group.projectLabel), ['Adventure', 'Props', 'Needs project'])
+  const heroFamily = result[0].families[0]
+  assert.equal(heroFamily.rootWorkspacePath, 'Default/hero.glb')
+  assert.equal(heroFamily.primaryEntry.id, 'derived')
+  assert.deepEqual(heroFamily.entries.map((item) => item.id), ['derived', 'root'])
+  assert.equal(result.reduce((count, group) => count + group.families.length, 0), 3)
+  assert.equal(result.reduce((count, group) => count + group.entryCount, 0), 4)
+  assert.deepEqual(getDefaultAssetLibraryCollapsedSectionKeys(), [])
+  assert.deepEqual(toggleAssetLibrarySectionKey([], 'project:adventure'), ['project:adventure'])
+})
+
+test('searches semantic metadata and lineage while filters answer real asset questions', () => {
+  const entries = [root, derived, prop, unnamed]
+
+  assert.deepEqual(groups(entries, 'clip-hero-walk').map((group) => group.projectLabel), ['Adventure'])
+  assert.deepEqual(groups(entries, 'Default/hero.glb')[0].families[0].entries.map((item) => item.id), ['derived', 'root'])
+  assert.deepEqual(groups(entries, 'props').map((group) => group.projectLabel), ['Props'])
+
+  assert.deepEqual(groups(entries, '', 'date', { kind: 'rigged', poly: 'all', needsAttention: false }).map((group) => group.projectLabel), ['Adventure'])
+  assert.deepEqual(groups(entries, '', 'date', { kind: 'animated', poly: 'all', needsAttention: false }).map((group) => group.projectLabel), ['Adventure'])
+  assert.deepEqual(groups(entries, '', 'date', { kind: 'character', poly: 'all', needsAttention: false }).map((group) => group.projectLabel), ['Adventure'])
+  assert.deepEqual(groups(entries, '', 'date', { kind: 'prop', poly: 'all', needsAttention: false }).map((group) => group.projectLabel), ['Props'])
+  assert.deepEqual(groups(entries, '', 'date', { kind: 'all', poly: 'high-poly', needsAttention: false }).map((group) => group.projectLabel), ['Needs project'])
+  assert.deepEqual(groups(entries, '', 'date', { kind: 'all', poly: 'all', needsAttention: true }).map((group) => group.projectLabel), ['Needs project'])
 })
 
-test('searches workspace assets by name path capability scope source and manifest while supporting name/date sorting', () => {
-  const entries = [
-    entry({ id: 'b', workspacePath: 'Workflows/run/zebra.glb', displayName: 'zebra.glb', sourceScope: 'workflows', capability: 'mesh', createdAt: '2026-06-15T10:00:00.000Z' }),
-    entry({ id: 'a', workspacePath: 'Exports/rig/alpha.gltf', displayName: 'alpha.gltf', sourceScope: 'exports', capability: 'rigged-mesh', createdAt: '2026-06-16T10:00:00.000Z' }),
-    entry({
-      id: 'c', workspacePath: 'Exports/motion/walk.json', displayName: 'walk.json', sourceScope: 'exports', capability: 'animation-motion', openable: false, previewKind: 'text',
-      source: { workspacePath: 'Workflows/run/zebra.glb', displayName: 'zebra.glb' },
-      manifest: { workspacePath: 'Exports/motion/walk.scene.json', capability: 'scene-manifest' },
-    }),
-  ]
-
-  assert.deepEqual(groupPaths(entries, 'rigged'), ['Exports/rig/alpha.gltf'])
-  assert.deepEqual(groupPaths(entries, 'walk.scene'), ['Exports/motion/walk.json'])
-  assert.deepEqual(groupPaths(entries, 'zebra.glb'), ['Workflows/run/zebra.glb', 'Exports/motion/walk.json'])
-  assert.deepEqual(groupPaths(entries, 'exports', 'name'), ['Exports/rig/alpha.gltf', 'Exports/motion/walk.json'])
-  assert.deepEqual(groupPaths(entries, '', 'date'), ['Workflows/run/zebra.glb', 'Exports/rig/alpha.gltf', 'Exports/motion/walk.json'])
+test('defaults to newest-first families and retains name and type sorting', () => {
+  const olderProp = entry({
+    id: 'older-prop',
+    workspacePath: 'Exports/props/table.glb',
+    displayName: 'Table',
+    sourceScope: 'exports',
+    createdAt: '2026-06-14T10:00:00.000Z',
+    semantic: { name: 'Table', project: 'Props', tags: ['prop', 'high-poly'] },
+  })
+
+  assert.deepEqual(groups([olderProp, prop])[0].families.map((family) => family.name), ['Chair', 'Table'])
+  assert.deepEqual(groups([olderProp, prop], '', 'name')[0].families.map((family) => family.name), ['Chair', 'Table'])
+  assert.deepEqual(groups([root, derived, prop], '', 'type').flatMap((group) => group.families.map((family) => family.name)), ['Hero Rigged', 'Chair'])
 })
 
-test('opens only safe glb and gltf entries through existing Generate job and history state', () => {
-  const glb = entry({ workspacePath: 'Workflows/run/hero.glb', displayName: 'hero.glb' })
-  const ply = entry({ workspacePath: 'Exports/scan.ply', displayName: 'scan.ply', openable: false, nonOpenableReason: 'Only .glb/.gltf workspace assets are openable in this release.' })
+test('opens safe Default, Workflows, and Exports models through existing Generate job state', () => {
+  const glb = entry({ workspacePath: 'Default/hero.glb', displayName: 'Hero' })
+  const ply = entry({ workspacePath: 'Exports/scan.ply', displayName: 'scan.ply', sourceScope: 'exports', openable: false, nonOpenableReason: 'Only .glb/.gltf workspace assets are openable in this release.' })
 
   assert.equal(isAssetLibraryEntryOpenable(glb), true)
   assert.equal(isAssetLibraryEntryOpenable(ply), false)
   assert.equal(describeAssetLibraryOpenability(glb), 'Ready to open this asset directly in Generate.')
   assert.equal(describeAssetLibraryOpenability(ply), 'Only .glb/.gltf workspace assets are openable in this release.')
-  assert.deepEqual(buildAssetLibraryOpenRequest(glb), { workspacePath: 'Workflows/run/hero.glb' })
+  assert.deepEqual(buildAssetLibraryOpenRequest(glb), { workspacePath: 'Default/hero.glb' })
 
   const target = resolveAssetLibraryOpenTarget(glb)
   assert.equal(target.kind, 'self')
   if (target.kind !== 'self') throw new Error('expected self target')
 
   const selection = createAssetLibraryOpenJob(glb, target, 1718546400000)
-  assert.equal(selection.historyUrl, '/workspace/Workflows/run/hero.glb')
+  assert.equal(selection.historyUrl, '/workspace/Default/hero.glb')
   assert.equal(selection.job.status, 'done')
-  assert.equal(selection.job.outputUrl, '/workspace/Workflows/run/hero.glb')
-  assert.equal(selection.job.originalOutputUrl, '/workspace/Workflows/run/hero.glb')
+  assert.equal(selection.job.libraryEntryId, glb.id)
+  assert.equal(selection.job.libraryWorkspacePath, glb.workspacePath)
   assert.equal(resolveOpenPanelAfterLibrarySelection('library' satisfies GenerateOpenPanel), 'library')
 })
 
@@ -103,23 +170,77 @@ test('builds linked-source open requests and import jobs for safe sidecars', ()
     id: 'sidecar',
     workspacePath: 'Workflows/run/hero.landmarks.v1.json',
     displayName: 'hero.landmarks.v1.json',
+    sourceScope: 'workflows',
     capability: 'landmarks-sidecar',
     previewKind: 'text',
     openable: false,
-    source: { workspacePath: 'Workflows/run/hero.glb', displayName: 'hero.glb' },
+    source: { workspacePath: 'Default/hero.glb', displayName: 'hero.glb' },
   })
 
   assert.equal(isAssetLibraryEntryOpenable(sidecar), true)
-  assert.equal(describeAssetLibraryOpenability(sidecar), 'Ready to open linked source hero.glb in Generate.')
   assert.deepEqual(buildAssetLibraryOpenRequest(sidecar), {
     workspacePath: 'Workflows/run/hero.landmarks.v1.json',
-    sourceWorkspacePath: 'Workflows/run/hero.glb',
+    sourceWorkspacePath: 'Default/hero.glb',
+  })
+})
+
+test('Library panel clamps to gallery-safe bounds and degrades silently without localStorage', () => {
+  assert.equal(clampAssetLibraryPanelWidth(0), 560)
+  assert.equal(clampAssetLibraryPanelWidth(9999), 1200)
+  assert.equal(clampAssetLibraryPanelWidth(700), 700)
+  assert.equal(getStoredAssetLibraryPanelWidth(), 880)
+  assert.doesNotThrow(() => storeAssetLibraryPanelWidth(700))
+
+  assert.equal(clampAssetLibraryPanelHeight(0), 420)
+  assert.equal(clampAssetLibraryPanelHeight(9999), 1200)
+  assert.equal(clampAssetLibraryPanelHeight(500), 500)
+  assert.equal(getStoredAssetLibraryPanelHeight(), 900)
+  assert.doesNotThrow(() => storeAssetLibraryPanelHeight(500))
+})
+
+test('Library panel shifts, shrinks, and flips to stay inside zoomed viewports', () => {
+  const zoomed = getAssetLibraryPanelLayout(
+    { left: 420, right: 500, top: 40, bottom: 70 },
+    { width: 640, height: 430 },
+    880,
+    900,
+  )
+  assert.deepEqual(zoomed, {
+    left: 12,
+    top: 74,
+    width: 616,
+    height: 344,
+    placement: 'below',
+  })
+  assert.ok(zoomed.left >= 0)
+  assert.ok(zoomed.left + zoomed.width <= 640)
+  assert.ok(zoomed.top + zoomed.height <= 430)
+
+  const flipped = getAssetLibraryPanelLayout(
+    { left: 700, right: 780, top: 700, bottom: 730 },
+    { width: 1000, height: 800 },
+    560,
+    600,
+  )
+  assert.deepEqual(flipped, {
+    left: 428,
+    top: 96,
+    width: 560,
+    height: 600,
+    placement: 'above',
   })
+})
+
+test('live discovery expands matching projects without overwriting collapse state', () => {
+  const collapsed = ['project:adventure']
+  assert.equal(isAssetLibrarySectionExpanded(collapsed, 'project:adventure', false), false)
+  assert.equal(isAssetLibrarySectionExpanded(collapsed, 'project:props', false), true)
+  assert.equal(isAssetLibrarySectionExpanded(collapsed, 'project:adventure', true), true)
+})
 
-  const target = resolveAssetLibraryOpenTarget(sidecar)
-  assert.equal(target.kind, 'linked-source')
-  if (target.kind !== 'linked-source') throw new Error('expected linked source target')
-  const selection = createAssetLibraryOpenJob(sidecar, target, 1718546400001)
-  assert.equal(selection?.historyUrl, '/workspace/Workflows/run/hero.glb')
-  assert.equal(selection?.job.outputUrl, '/workspace/Workflows/run/hero.glb')
+test('formats machine clip names as legible animation names', () => {
+  assert.equal(formatAssetLibraryClipName('slow_turn_glance'), 'Slow Turn Glance')
+  assert.equal(formatAssetLibraryClipName('RigAction'), 'Rig Action')
+  assert.equal(findAssetLibraryMotionClipIndex([{ name: 'Idle' }, { name: 'slow-turn_glance' }], 'slow_turn_glance'), 1)
+  assert.equal(findAssetLibraryMotionClipIndex([{ name: 'Idle' }], 'Walk'), -1)
 })
diff --git a/src/areas/generate/assetLibraryUi.ts b/src/areas/generate/assetLibraryUi.ts
index 5e83e65a..0b15a2d9 100644
--- a/src/areas/generate/assetLibraryUi.ts
+++ b/src/areas/generate/assetLibraryUi.ts
@@ -3,20 +3,33 @@ import type { AssetLibraryOpenRequest } from '../../shared/types/assetLibrary'
 import { resolveAssetLibraryOpenTarget, type AssetLibraryOpenTarget, type ProjectedAssetLibraryEntry } from './assetLibraryProjection'
 
 export type GenerateOpenPanel = 'export' | 'decimate' | 'smooth' | 'import' | 'library' | 'light' | null
-export type AssetLibrarySortMode = 'type' | 'name' | 'date'
+export type AssetLibrarySortMode = 'date' | 'name' | 'type'
+export type AssetLibraryViewMode = 'gallery' | 'list'
+export type AssetLibraryKindFilter = 'all' | 'rigged' | 'animated' | 'character' | 'prop'
+export type AssetLibraryPolyFilter = 'all' | 'low-poly' | 'mid-poly' | 'high-poly'
+
+export interface AssetLibraryFilters {
+  kind: AssetLibraryKindFilter
+  poly: AssetLibraryPolyFilter
+  needsAttention: boolean
+}
 
-export interface AssetLibraryEntryGroup {
-  capability: NonNullable<ProjectedAssetLibraryEntry['capability']>
-  capabilityLabel: string
-  sectionKey: string
+export interface AssetLibraryLineageFamily {
+  key: string
+  rootWorkspacePath: string
+  name: string
+  project?: string
   entries: ProjectedAssetLibraryEntry[]
+  primaryEntry: ProjectedAssetLibraryEntry
+  tags: string[]
 }
 
-export interface AssetLibrarySourceScopeGroup {
-  sourceScope: ProjectedAssetLibraryEntry['sourceScope']
-  sourceScopeLabel: string
+export interface AssetLibraryProjectGroup {
+  projectKey: string
+  projectLabel: string
   sectionKey: string
-  entryGroups: AssetLibraryEntryGroup[]
+  families: AssetLibraryLineageFamily[]
+  entryCount: number
 }
 
 export interface AssetLibraryOpenSelection {
@@ -24,42 +37,36 @@ export interface AssetLibraryOpenSelection {
   job: GenerationJob
 }
 
-const ASSET_LIBRARY_CAPABILITY_SECTIONS = [
-  { capability: 'mesh', label: 'Mesh' },
-  { capability: 'rigged-mesh', label: 'Rigged mesh' },
-  { capability: 'animation-motion', label: 'Animations/motions' },
-  { capability: 'landmarks-sidecar', label: 'Landmarks sidecars' },
-  { capability: 'generated-world', label: 'Generated worlds' },
-  { capability: 'scene-manifest', label: 'Scene manifests' },
-] as const satisfies ReadonlyArray<{ capability: NonNullable<ProjectedAssetLibraryEntry['capability']>, label: string }>
-
-const ASSET_LIBRARY_SOURCE_SCOPE_SECTIONS = [
-  { sourceScope: 'workflows', label: 'Workflows' },
-  { sourceScope: 'exports', label: 'Exports' },
-] as const satisfies ReadonlyArray<{ sourceScope: ProjectedAssetLibraryEntry['sourceScope'], label: string }>
+export const ASSET_LIBRARY_SORT_OPTIONS = [
+  { value: 'date', label: 'Recently added' },
+  { value: 'name', label: 'Name A–Z' },
+  { value: 'type', label: 'Asset type' },
+] as const satisfies ReadonlyArray<{ value: AssetLibrarySortMode, label: string }>
 
-const ASSET_LIBRARY_CAPABILITY_ORDER = new Map(
-  ASSET_LIBRARY_CAPABILITY_SECTIONS.map((section, index) => [section.capability, index]),
-)
+export const ASSET_LIBRARY_KIND_FILTERS = [
+  { value: 'all', label: 'All assets' },
+  { value: 'rigged', label: 'Rigged' },
+  { value: 'animated', label: 'Animated' },
+  { value: 'character', label: 'Characters' },
+  { value: 'prop', label: 'Props' },
+] as const satisfies ReadonlyArray<{ value: AssetLibraryKindFilter, label: string }>
+
+export const ASSET_LIBRARY_POLY_FILTERS = [
+  { value: 'all', label: 'Any weight' },
+  { value: 'low-poly', label: 'Light' },
+  { value: 'mid-poly', label: 'Medium' },
+  { value: 'high-poly', label: 'Heavy' },
+] as const satisfies ReadonlyArray<{ value: AssetLibraryPolyFilter, label: string }>
 
 const ASSET_LIBRARY_INTERNAL_DIRECTORY_NAMES = new Set(['tmp', 'temp', 'cache'])
+const NEEDS_PROJECT_KEY = 'needs-project'
 
-export const ASSET_LIBRARY_SORT_OPTIONS = [
-  { value: 'type', label: 'Type' },
-  { value: 'name', label: 'Name' },
-  { value: 'date', label: 'Date' },
-] as const satisfies ReadonlyArray<{ value: AssetLibrarySortMode, label: string }>
+export function createDefaultAssetLibraryFilters(): AssetLibraryFilters {
+  return { kind: 'all', poly: 'all', needsAttention: false }
+}
 
 export function getDefaultAssetLibraryCollapsedSectionKeys(): string[] {
-  const sectionKeys = ASSET_LIBRARY_SOURCE_SCOPE_SECTIONS.flatMap((scopeSection) => {
-    const capabilityKeys = ASSET_LIBRARY_CAPABILITY_SECTIONS.map(
-      (capabilitySection) => `capability:${scopeSection.sourceScope}:${capabilitySection.capability}`,
-    )
-
-    return [`scope:${scopeSection.sourceScope}`, ...capabilityKeys]
-  })
-
-  return [...sectionKeys]
+  return []
 }
 
 export function toggleAssetLibrarySectionKey(currentKeys: string[], sectionKey: string): string[] {
@@ -68,6 +75,18 @@ export function toggleAssetLibrarySectionKey(currentKeys: string[], sectionKey:
     : [...currentKeys, sectionKey]
 }
 
+/**
+ * Search and semantic filters always expose their matching projects. Clearing
+ * them restores the operator's untouched collapse choices.
+ */
+export function isAssetLibrarySectionExpanded(
+  collapsedSectionKeys: string[],
+  sectionKey: string,
+  hasActiveDiscovery: boolean,
+): boolean {
+  return hasActiveDiscovery || !collapsedSectionKeys.includes(sectionKey)
+}
+
 export function buildAssetLibraryOpenRequest(entry: ProjectedAssetLibraryEntry): AssetLibraryOpenRequest {
   const target = resolveAssetLibraryOpenTarget(entry)
   return target.kind === 'linked-source'
@@ -95,53 +114,83 @@ export function filterVisibleAssetLibraryEntries(entries: ProjectedAssetLibraryE
   return entries.filter((entry) => entry.state !== 'unsupported' && !hasInternalAssetLibraryDirectory(entry.workspacePath))
 }
 
-export function filterAssetLibraryScopeGroups(
+export function buildAssetLibraryProjectGroups(
   entries: ProjectedAssetLibraryEntry[],
   searchQuery: string,
   sortMode: AssetLibrarySortMode,
-): AssetLibrarySourceScopeGroup[] {
+  filters: AssetLibraryFilters,
+): AssetLibraryProjectGroup[] {
   const normalizedSearchQuery = normalizeAssetLibrarySearchQuery(searchQuery)
-  const visibleEntries = filterVisibleAssetLibraryEntries(entries)
-
-  return ASSET_LIBRARY_SOURCE_SCOPE_SECTIONS
-    .map((scopeSection) => {
-      const scopeEntries = visibleEntries.filter((entry) => entry.sourceScope === scopeSection.sourceScope)
-      const scopeMatches = normalizedSearchQuery.length > 0 && matchesAssetLibrarySearch(scopeSection.label, normalizedSearchQuery)
-
-      const entryGroups = ASSET_LIBRARY_CAPABILITY_SECTIONS
-        .map((capabilitySection) => {
-          const capabilityEntries = scopeEntries.filter((entry) => entry.capability === capabilitySection.capability)
-          if (capabilityEntries.length === 0) return null
-
-          const capabilityMatches = scopeMatches || (normalizedSearchQuery.length > 0 && matchesAssetLibrarySearch(capabilitySection.label, normalizedSearchQuery))
-          const visibleCapabilityEntries = !normalizedSearchQuery || capabilityMatches
-            ? capabilityEntries
-            : capabilityEntries.filter((entry) => matchesAssetLibraryEntrySearch(entry, normalizedSearchQuery))
-
-          if (visibleCapabilityEntries.length === 0) return null
-
-          return {
-            capability: capabilitySection.capability,
-            capabilityLabel: capabilitySection.label,
-            sectionKey: `capability:${scopeSection.sourceScope}:${capabilitySection.capability}`,
-            entries: sortAssetLibraryEntries(visibleCapabilityEntries, sortMode),
-          }
-        })
-        .filter((group): group is AssetLibraryEntryGroup => group !== null)
-
-      const sortedEntryGroups = sortMode === 'type'
-        ? entryGroups
-        : [...entryGroups].sort((left, right) => compareAssetLibraryEntryGroups(left, right, sortMode))
-
-      if (sortedEntryGroups.length === 0) return null
-      return {
-        sourceScope: scopeSection.sourceScope,
-        sourceScopeLabel: scopeSection.label,
-        sectionKey: `scope:${scopeSection.sourceScope}`,
-        entryGroups: sortedEntryGroups,
-      }
-    })
-    .filter((group): group is AssetLibrarySourceScopeGroup => group !== null)
+  const families = buildAssetLibraryLineageFamilies(filterVisibleAssetLibraryEntries(entries))
+    .filter((family) => (
+      (!normalizedSearchQuery || matchesAssetLibraryFamilySearch(family, normalizedSearchQuery))
+      && family.entries.some((entry) => matchesAssetLibraryFilters(entry, filters))
+    ))
+
+  const groups = new Map<string, AssetLibraryProjectGroup>()
+  for (const family of families) {
+    const projectLabel = family.project ?? 'Needs project'
+    const projectKey = family.project
+      ? normalizeProjectKey(family.project)
+      : NEEDS_PROJECT_KEY
+    const current = groups.get(projectKey) ?? {
+      projectKey,
+      projectLabel,
+      sectionKey: `project:${projectKey}`,
+      families: [],
+      entryCount: 0,
+    }
+    current.families.push(family)
+    current.entryCount += family.entries.length
+    groups.set(projectKey, current)
+  }
+
+  return [...groups.values()]
+    .map((group) => ({
+      ...group,
+      families: [...group.families].sort((left, right) => compareAssetLibraryFamilies(left, right, sortMode)),
+    }))
+    .sort(compareAssetLibraryProjectGroups)
+}
+
+export function buildAssetLibraryLineageFamilies(
+  entries: ProjectedAssetLibraryEntry[],
+): AssetLibraryLineageFamily[] {
+  const grouped = new Map<string, ProjectedAssetLibraryEntry[]>()
+  for (const entry of entries) {
+    const rootWorkspacePath = entry.semantic?.derivedFrom?.root.workspacePath ?? entry.workspacePath
+    grouped.set(rootWorkspacePath, [...(grouped.get(rootWorkspacePath) ?? []), entry])
+  }
+
+  return [...grouped.entries()].map(([rootWorkspacePath, familyEntries]) => {
+    const sortedEntries = [...familyEntries].sort((left, right) => compareAssetLibraryEntries(left, right, 'date'))
+    const primaryEntry = sortedEntries[0]
+    const namedEntry = sortedEntries.find((entry) => entry.semantic?.name)
+    const rootName = sortedEntries
+      .map((entry) => entry.semantic?.derivedFrom?.root.displayName)
+      .find((name): name is string => Boolean(name))
+    const project = primaryEntry.semantic?.project
+      ?? sortedEntries.map((entry) => entry.semantic?.project).find((value): value is string => Boolean(value))
+
+    return {
+      key: rootWorkspacePath,
+      rootWorkspacePath,
+      name: primaryEntry.semantic?.name ?? namedEntry?.semantic?.name ?? rootName ?? primaryEntry.displayName,
+      project,
+      entries: sortedEntries,
+      primaryEntry,
+      tags: [...new Set(sortedEntries.flatMap((entry) => entry.semantic?.tags ?? []))],
+    }
+  })
+}
+
+export function formatAssetLibraryClipName(clip: string): string {
+  const words = clip
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[_-]+/g, ' ')
+    .trim()
+  if (!words) return 'Animation'
+  return words.replace(/\b\w/g, (letter) => letter.toUpperCase())
 }
 
 export function createAssetLibraryOpenJob(
@@ -159,6 +208,8 @@ export function createAssetLibraryOpenJob(
       progress: 100,
       outputUrl: target.url,
       originalOutputUrl: target.url,
+      libraryEntryId: entry.id,
+      libraryWorkspacePath: entry.workspacePath,
       createdAt: now,
     },
   }
@@ -168,23 +219,158 @@ export function resolveOpenPanelAfterLibrarySelection(currentPanel: GenerateOpen
   return currentPanel === 'library' ? 'library' : currentPanel
 }
 
-function sortAssetLibraryEntries(
-  entries: ProjectedAssetLibraryEntry[],
-  sortMode: AssetLibrarySortMode,
-): ProjectedAssetLibraryEntry[] {
-  return [...entries].sort((left, right) => compareAssetLibraryEntries(left, right, sortMode))
+// Gallery-first dimensions: even the narrowest supported panel keeps a
+// motion preview well above the old 40px row thumbnail.
+export const ASSET_LIBRARY_PANEL_MIN_WIDTH = 560
+export const ASSET_LIBRARY_PANEL_MAX_WIDTH = 1200
+export const ASSET_LIBRARY_PANEL_DEFAULT_WIDTH = 880
+
+const ASSET_LIBRARY_PANEL_WIDTH_STORAGE_KEY = 'modly-library-panel-width'
+
+export function clampAssetLibraryPanelWidth(width: number): number {
+  return Math.min(ASSET_LIBRARY_PANEL_MAX_WIDTH, Math.max(ASSET_LIBRARY_PANEL_MIN_WIDTH, width))
+}
+
+export function getStoredAssetLibraryPanelWidth(): number {
+  try {
+    const raw = Number(localStorage.getItem(ASSET_LIBRARY_PANEL_WIDTH_STORAGE_KEY))
+    return Number.isFinite(raw) && raw > 0 ? clampAssetLibraryPanelWidth(raw) : ASSET_LIBRARY_PANEL_DEFAULT_WIDTH
+  } catch {
+    return ASSET_LIBRARY_PANEL_DEFAULT_WIDTH
+  }
+}
+
+export function storeAssetLibraryPanelWidth(width: number): void {
+  try {
+    localStorage.setItem(ASSET_LIBRARY_PANEL_WIDTH_STORAGE_KEY, String(width))
+  } catch {
+    // The panel still works when storage is unavailable.
+  }
+}
+
+export const ASSET_LIBRARY_PANEL_MIN_HEIGHT = 420
+export const ASSET_LIBRARY_PANEL_MAX_HEIGHT = 1200
+export const ASSET_LIBRARY_PANEL_DEFAULT_HEIGHT = 900
+
+const ASSET_LIBRARY_PANEL_HEIGHT_STORAGE_KEY = 'modly-library-panel-height'
+
+export function clampAssetLibraryPanelHeight(height: number): number {
+  return Math.min(ASSET_LIBRARY_PANEL_MAX_HEIGHT, Math.max(ASSET_LIBRARY_PANEL_MIN_HEIGHT, height))
 }
 
-function compareAssetLibraryEntryGroups(
-  left: AssetLibraryEntryGroup,
-  right: AssetLibraryEntryGroup,
-  sortMode: Exclude<AssetLibrarySortMode, 'type'>,
+export function getStoredAssetLibraryPanelHeight(): number {
+  try {
+    const raw = Number(localStorage.getItem(ASSET_LIBRARY_PANEL_HEIGHT_STORAGE_KEY))
+    return Number.isFinite(raw) && raw > 0 ? clampAssetLibraryPanelHeight(raw) : ASSET_LIBRARY_PANEL_DEFAULT_HEIGHT
+  } catch {
+    return ASSET_LIBRARY_PANEL_DEFAULT_HEIGHT
+  }
+}
+
+export function storeAssetLibraryPanelHeight(height: number): void {
+  try {
+    localStorage.setItem(ASSET_LIBRARY_PANEL_HEIGHT_STORAGE_KEY, String(height))
+  } catch {
+    // The panel still works when storage is unavailable.
+  }
+}
+
+export interface AssetLibraryAnchorRect {
+  left: number
+  right: number
+  top: number
+  bottom: number
+}
+
+export interface AssetLibraryViewport {
+  width: number
+  height: number
+}
+
+export interface AssetLibraryPanelLayout {
+  left: number
+  top: number
+  width: number
+  height: number
+  placement: 'above' | 'below'
+}
+
+/**
+ * Fits the popover into the renderer's CSS viewport. Chromium shrinks that
+ * viewport as whole-window zoom increases, so saved pixel preferences remain
+ * preferences rather than unreachable off-screen dimensions.
+ */
+export function getAssetLibraryPanelLayout(
+  anchor: AssetLibraryAnchorRect,
+  viewport: AssetLibraryViewport,
+  preferredWidth: number,
+  preferredHeight: number,
+  margin = 12,
+  gap = 4,
+): AssetLibraryPanelLayout {
+  const availableWidth = Math.max(0, viewport.width - margin * 2)
+  const width = Math.min(preferredWidth, availableWidth)
+  const left = Math.min(
+    Math.max(margin, anchor.left),
+    Math.max(margin, viewport.width - margin - width),
+  )
+
+  const belowSpace = Math.max(0, viewport.height - margin - anchor.bottom - gap)
+  const aboveSpace = Math.max(0, anchor.top - gap - margin)
+  const minimumUsefulHeight = Math.min(preferredHeight, ASSET_LIBRARY_PANEL_MIN_HEIGHT)
+  const placement = belowSpace < minimumUsefulHeight && aboveSpace > belowSpace ? 'above' : 'below'
+  const availableHeight = placement === 'below' ? belowSpace : aboveSpace
+  const height = Math.min(preferredHeight, availableHeight)
+  const top = placement === 'below'
+    ? anchor.bottom + gap
+    : Math.max(margin, anchor.top - gap - height)
+
+  return { left, top, width, height, placement }
+}
+
+function normalizeClipIdentity(name: string): string {
+  return name.trim().toLocaleLowerCase().replace(/[^a-z0-9]+/g, '')
+}
+
+/** Matches preview-manifest clip names to the viewer's glTF animation list. */
+export function findAssetLibraryMotionClipIndex(
+  clips: Array<{ name: string }>,
+  previewClip: string,
 ): number {
-  const entryComparison = compareAssetLibraryEntries(left.entries[0], right.entries[0], sortMode)
-  if (entryComparison !== 0) return entryComparison
+  const exact = clips.findIndex((clip) => clip.name === previewClip)
+  if (exact >= 0) return exact
+  const normalized = normalizeClipIdentity(previewClip)
+  return clips.findIndex((clip) => normalizeClipIdentity(clip.name) === normalized)
+}
 
-  return (ASSET_LIBRARY_CAPABILITY_ORDER.get(left.capability) ?? Number.MAX_SAFE_INTEGER)
-    - (ASSET_LIBRARY_CAPABILITY_ORDER.get(right.capability) ?? Number.MAX_SAFE_INTEGER)
+function compareAssetLibraryProjectGroups(left: AssetLibraryProjectGroup, right: AssetLibraryProjectGroup): number {
+  if (left.projectKey === NEEDS_PROJECT_KEY && right.projectKey !== NEEDS_PROJECT_KEY) return 1
+  if (right.projectKey === NEEDS_PROJECT_KEY && left.projectKey !== NEEDS_PROJECT_KEY) return -1
+  return left.projectLabel.localeCompare(right.projectLabel, undefined, { sensitivity: 'base' })
+}
+
+function compareAssetLibraryFamilies(
+  left: AssetLibraryLineageFamily,
+  right: AssetLibraryLineageFamily,
+  sortMode: AssetLibrarySortMode,
+): number {
+  if (sortMode === 'name') {
+    return left.name.localeCompare(right.name, undefined, { sensitivity: 'base' })
+  }
+  if (sortMode === 'type') {
+    const rankDifference = assetLibraryFamilyTypeRank(left) - assetLibraryFamilyTypeRank(right)
+    if (rankDifference !== 0) return rankDifference
+    return left.name.localeCompare(right.name, undefined, { sensitivity: 'base' })
+  }
+  return compareAssetLibraryEntries(left.primaryEntry, right.primaryEntry, 'date')
+}
+
+function assetLibraryFamilyTypeRank(family: AssetLibraryLineageFamily): number {
+  if (family.tags.includes('animated')) return 0
+  if (family.tags.includes('rigged')) return 1
+  if (family.tags.includes('character') || family.tags.includes('creature')) return 2
+  if (family.tags.includes('prop')) return 3
+  return 4
 }
 
 function compareAssetLibraryEntries(
@@ -200,10 +386,6 @@ function compareAssetLibraryEntries(
     if (leftTime === null && rightTime !== null) return 1
   }
 
-  return compareAssetLibraryEntryNames(left, right)
-}
-
-function compareAssetLibraryEntryNames(left: ProjectedAssetLibraryEntry, right: ProjectedAssetLibraryEntry): number {
   const displayNameComparison = left.displayName.localeCompare(right.displayName, undefined, { sensitivity: 'base' })
   if (displayNameComparison !== 0) return displayNameComparison
   const workspacePathComparison = left.workspacePath.localeCompare(right.workspacePath, undefined, { sensitivity: 'base' })
@@ -221,8 +403,22 @@ function parseAssetLibrarySortTimestamp(value: string | undefined): number | nul
   return Number.isFinite(epochMs) ? epochMs : null
 }
 
-function normalizeAssetLibrarySearchQuery(searchQuery: string): string {
-  return searchQuery.trim().toLocaleLowerCase()
+function matchesAssetLibraryFilters(entry: ProjectedAssetLibraryEntry, filters: AssetLibraryFilters): boolean {
+  const tags = new Set(entry.semantic?.tags ?? [])
+  const kindMatches = filters.kind === 'all'
+    || (filters.kind === 'rigged' && (tags.has('rigged') || entry.capability === 'rigged-mesh'))
+    || (filters.kind === 'animated' && tags.has('animated'))
+    || (filters.kind === 'character' && ['character', 'characters', 'creature'].some((tag) => tags.has(tag)))
+    || (filters.kind === 'prop' && ['prop', 'props'].some((tag) => tags.has(tag)))
+  const polyMatches = filters.poly === 'all' || tags.has(filters.poly)
+  const attentionMatches = !filters.needsAttention || tags.has('unnamed') || !entry.semantic?.name
+  return kindMatches && polyMatches && attentionMatches
+}
+
+function matchesAssetLibraryFamilySearch(family: AssetLibraryLineageFamily, normalizedSearchQuery: string): boolean {
+  return matchesAssetLibrarySearch(family.name, normalizedSearchQuery)
+    || matchesAssetLibrarySearch(family.project ?? '', normalizedSearchQuery)
+    || family.entries.some((entry) => matchesAssetLibraryEntrySearch(entry, normalizedSearchQuery))
 }
 
 function matchesAssetLibraryEntrySearch(entry: ProjectedAssetLibraryEntry, normalizedSearchQuery: string): boolean {
@@ -234,16 +430,29 @@ function matchesAssetLibraryEntrySearch(entry: ProjectedAssetLibraryEntry, norma
     entry.manifest?.workspacePath,
     entry.capability,
     entry.sourceScope,
+    entry.semantic?.name,
+    entry.semantic?.project,
+    entry.semantic?.derivedFrom?.parent.workspacePath,
+    entry.semantic?.derivedFrom?.root.workspacePath,
     ...entry.warnings,
+    ...(entry.semantic?.tags ?? []),
   ]
     .filter((value): value is string => typeof value === 'string' && value.length > 0)
     .some((value) => matchesAssetLibrarySearch(value, normalizedSearchQuery))
 }
 
+function normalizeAssetLibrarySearchQuery(searchQuery: string): string {
+  return searchQuery.trim().toLocaleLowerCase()
+}
+
 function matchesAssetLibrarySearch(value: string, normalizedSearchQuery: string): boolean {
   return value.toLocaleLowerCase().includes(normalizedSearchQuery)
 }
 
+function normalizeProjectKey(project: string): string {
+  return project.toLocaleLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || NEEDS_PROJECT_KEY
+}
+
 function hasInternalAssetLibraryDirectory(workspacePath: string): boolean {
   const segments = workspacePath.replace(/\\/g, '/').trim().split('/').filter(Boolean)
   return segments.slice(1, -1).some((segment) => segment.startsWith('.') || ASSET_LIBRARY_INTERNAL_DIRECTORY_NAMES.has(segment.toLocaleLowerCase()))
diff --git a/src/areas/generate/components/ChatPanel.tsx b/src/areas/generate/components/ChatPanel.tsx
index 7618f75d..f9e49a2f 100644
--- a/src/areas/generate/components/ChatPanel.tsx
+++ b/src/areas/generate/components/ChatPanel.tsx
@@ -269,6 +269,8 @@ export default function ChatPanel(): JSX.Element {
   const updateCurrentJob = useAppStore((s) => s.updateCurrentJob)
   const pushMeshUrl      = useAppStore((s) => s.pushMeshUrl)
   const undoMesh         = useAppStore((s) => s.undoMesh)
+  const motionClips      = useAppStore((s) => s.motionClips)
+  const activeClipIndex  = useAppStore((s) => s.activeClipIndex)
 
   const workflows     = useWorkflowsStore((s) => s.workflows)
   const saveWorkflow  = useWorkflowsStore((s) => s.save)
@@ -329,6 +331,10 @@ export default function ChatPanel(): JSX.Element {
     const ctx: Record<string, unknown> = {}
     if (currentJob?.outputUrl) ctx.currentMeshPath = currentJob.outputUrl.replace('/workspace/', '')
     if (meshStats?.triangles)  ctx.meshTriangles   = meshStats.triangles
+    if (motionClips.length > 0) {
+      ctx.currentClipName = motionClips[Math.min(activeClipIndex, motionClips.length - 1)]?.name
+      ctx.availableClips  = motionClips.map((c) => c.name)
+    }
     if (workflows.length > 0)  ctx.workflows       = workflows.map((w) => ({ id: w.id, name: w.name }))
     if (allExtensions.length > 0) ctx.extensions   = allExtensions.map((e) => ({
       id: e.id, name: e.name, input: e.input, output: e.output,
diff --git a/src/areas/generate/components/LiveTexturePanel.tsx b/src/areas/generate/components/LiveTexturePanel.tsx
new file mode 100644
index 00000000..63f3c52f
--- /dev/null
+++ b/src/areas/generate/components/LiveTexturePanel.tsx
@@ -0,0 +1,202 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import * as THREE from 'three'
+
+import type { TextureWatchUpdate } from '@shared/types/liveTexture'
+import {
+  findLiveTextureTarget,
+  prepareLiveTexture,
+  replaceLiveTexture,
+} from './liveTexture'
+
+type PanelState =
+  | { kind: 'idle' }
+  | { kind: 'reading'; fileName: string; message: string }
+  | { kind: 'watching'; fileName: string; updatedAt: number }
+  | { kind: 'error'; fileName?: string; message: string }
+
+interface LiveTexturePanelProps {
+  object: THREE.Object3D | null
+  onApplied: () => void
+}
+
+function timeLabel(value: number): string {
+  return new Date(value).toLocaleTimeString([], {
+    hour: 'numeric',
+    minute: '2-digit',
+    second: '2-digit',
+  })
+}
+
+export default function LiveTexturePanel({ object, onApplied }: LiveTexturePanelProps): JSX.Element {
+  const [watching, setWatching] = useState(false)
+  const [panel, setPanel] = useState<PanelState>({ kind: 'idle' })
+  const latestRevision = useRef(0)
+  const latestTexture = useRef<THREE.Texture | null>(null)
+
+  const acceptUpdate = useCallback(async (update: TextureWatchUpdate): Promise<void> => {
+    if (update.revision < latestRevision.current) return
+    latestRevision.current = update.revision
+
+    if (update.state === 'reading') {
+      setPanel({
+        kind: 'reading',
+        fileName: update.fileName,
+        message: update.message ?? 'Checking the saved texture…',
+      })
+      return
+    }
+    if (update.state === 'error') {
+      setPanel({
+        kind: 'error',
+        fileName: update.fileName,
+        message: update.message ?? 'The saved texture could not be read.',
+      })
+      return
+    }
+
+    const found = object ? findLiveTextureTarget(object) : null
+    if (!found?.ok) {
+      setPanel({
+        kind: 'error',
+        fileName: update.fileName,
+        message: found?.message ?? 'The model is not ready for texture updates.',
+      })
+      return
+    }
+
+    const { target } = found
+    if (update.width !== target.width || update.height !== target.height) {
+      setPanel({
+        kind: 'error',
+        fileName: update.fileName,
+        message: `This texture is ${update.width ?? '?'} × ${update.height ?? '?'}. The model uses ${target.width} × ${target.height}. Save it at ${target.width} × ${target.height} to update the preview.`,
+      })
+      return
+    }
+    if (!update.dataUrl) {
+      setPanel({
+        kind: 'error',
+        fileName: update.fileName,
+        message: 'The saved texture was empty and the preview was not updated.',
+      })
+      return
+    }
+
+    let texture: THREE.Texture
+    try {
+      texture = await new THREE.TextureLoader().loadAsync(update.dataUrl)
+    } catch {
+      if (update.revision !== latestRevision.current) return
+      setPanel({
+        kind: 'error',
+        fileName: update.fileName,
+        message: 'The saved texture could not be opened. It may still be saving or the file may be damaged.',
+      })
+      return
+    }
+
+    if (update.revision !== latestRevision.current) {
+      texture.dispose()
+      return
+    }
+
+    prepareLiveTexture(texture, target.texture)
+    replaceLiveTexture(target, texture)
+    latestTexture.current?.dispose()
+    latestTexture.current = texture
+    onApplied()
+
+    const appliedAt = Date.now()
+    setPanel({ kind: 'watching', fileName: update.fileName, updatedAt: appliedAt })
+    window.dispatchEvent(new CustomEvent('modly:texture-updated', {
+      detail: {
+        filePath: update.filePath,
+        revision: update.revision,
+        detectedAt: update.changedAt,
+        savedAt: update.savedAt,
+        appliedAt,
+      },
+    }))
+  }, [object, onApplied])
+
+  useEffect(() => {
+    window.electron.texture.onChange(acceptUpdate)
+    return () => window.electron.texture.offChange()
+  }, [acceptUpdate])
+
+  useEffect(() => () => {
+    void window.electron.texture.stopWatching()
+    latestTexture.current?.dispose()
+    latestTexture.current = null
+  }, [])
+
+  const toggleWatching = async (): Promise<void> => {
+    if (watching) {
+      await window.electron.texture.stopWatching()
+      setWatching(false)
+      setPanel({ kind: 'idle' })
+      latestRevision.current = 0
+      return
+    }
+
+    const found = object ? findLiveTextureTarget(object) : null
+    if (!found?.ok) {
+      setPanel({
+        kind: 'error',
+        message: found?.message ?? 'The model is not ready for texture updates.',
+      })
+      return
+    }
+
+    const choice = await window.electron.texture.chooseAndWatch()
+    if (choice.cancelled) return
+    setWatching(true)
+    await acceptUpdate(choice.update)
+  }
+
+  return (
+    <div className="absolute top-4 left-1/2 -translate-x-1/2 z-20 flex items-stretch overflow-hidden rounded-lg border border-zinc-700/60 bg-zinc-900/85 shadow-lg backdrop-blur-sm">
+      <button
+        type="button"
+        data-testid="watch-texture-button"
+        onClick={() => { void toggleWatching() }}
+        className={`px-3 py-2 text-xs transition-colors ${
+          watching
+            ? 'bg-violet-600 text-white hover:bg-violet-500'
+            : 'text-zinc-300 hover:bg-zinc-700/70 hover:text-white'
+        }`}
+      >
+        {watching ? 'Stop watching' : 'Watch texture'}
+      </button>
+
+      {panel.kind !== 'idle' && (
+        <div
+          data-testid="texture-watch-status"
+          role={panel.kind === 'error' ? 'alert' : 'status'}
+          className={`max-w-[460px] border-l px-3 py-1.5 ${
+            panel.kind === 'error'
+              ? 'border-red-500/50 bg-red-950/70'
+              : 'border-zinc-700/60'
+          }`}
+        >
+          <p className={`truncate text-xs font-medium ${
+            panel.kind === 'error' ? 'text-red-200' : 'text-zinc-200'
+          }`}>
+            {panel.kind === 'error'
+              ? 'Texture not updated'
+              : panel.kind === 'reading'
+                ? `Checking ${panel.fileName}`
+                : `Watching ${panel.fileName}`}
+          </p>
+          <p className={`text-[10px] leading-tight ${
+            panel.kind === 'error' ? 'text-red-300' : 'text-zinc-500'
+          } ${panel.kind === 'error' ? 'whitespace-normal' : 'truncate'}`}>
+            {panel.kind === 'watching'
+              ? `Updated ${timeLabel(panel.updatedAt)}`
+              : panel.message}
+          </p>
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/src/areas/generate/components/MotionBar.tsx b/src/areas/generate/components/MotionBar.tsx
new file mode 100644
index 00000000..293f2435
--- /dev/null
+++ b/src/areas/generate/components/MotionBar.tsx
@@ -0,0 +1,48 @@
+export interface MotionClip {
+  name: string
+}
+
+interface MotionBarProps {
+  clips:       MotionClip[]
+  activeIndex: number
+  onChange:    (index: number) => void
+}
+
+function clipLabel(clip: MotionClip, index: number): string {
+  return clip.name || `Motion ${index + 1}`
+}
+
+/** Bottom-left overlay for scrubbing a rigged model's animation clips. */
+export function MotionBar({ clips, activeIndex, onChange }: MotionBarProps): JSX.Element | null {
+  if (clips.length === 0) return null
+
+  if (clips.length === 1) {
+    return (
+      <div className="flex items-center gap-2 bg-zinc-900/70 border border-zinc-700/50 backdrop-blur-sm rounded-xl px-3 py-1.5 pointer-events-none">
+        <span className="text-[10px] text-zinc-500">Playing</span>
+        <span className="text-xs text-zinc-300">{clipLabel(clips[0], 0)}</span>
+      </div>
+    )
+  }
+
+  return (
+    <div className="flex items-center gap-2 bg-zinc-900/70 border border-zinc-700/50 backdrop-blur-sm rounded-xl px-2 py-1.5">
+      <span className="text-[10px] text-zinc-500 pl-1">Motion</span>
+      <select
+        value={activeIndex}
+        onChange={(e) => onChange(Number(e.target.value))}
+        className="bg-zinc-800 text-zinc-200 border border-zinc-700 rounded-md px-2 py-1 text-xs focus:outline-none focus:border-accent/60"
+      >
+        {clips.map((clip, i) => (
+          <option key={i} value={i}>{clipLabel(clip, i)}</option>
+        ))}
+      </select>
+      <button
+        onClick={() => onChange((activeIndex + 1) % clips.length)}
+        className="px-2 py-1 rounded-md text-[11px] font-medium bg-zinc-700 hover:bg-zinc-600 text-zinc-200 transition-colors"
+      >
+        Next
+      </button>
+    </div>
+  )
+}
diff --git a/src/areas/generate/components/Viewer3D.tsx b/src/areas/generate/components/Viewer3D.tsx
index 8cff822f..21eddc71 100644
--- a/src/areas/generate/components/Viewer3D.tsx
+++ b/src/areas/generate/components/Viewer3D.tsx
@@ -16,6 +16,8 @@ import SplatViewer, { type SplatViewerHandle } from './SplatViewer'
 import { useGeneration } from '@shared/hooks/useGeneration'
 import { useAppStore } from '@shared/stores/appStore'
 import { ViewerToolbar, type ViewMode } from './ViewerToolbar'
+import { MotionBar, type MotionClip } from './MotionBar'
+import LiveTexturePanel from './LiveTexturePanel'
 import type { LightSettings } from '@shared/stores/appStore'
 import { DEFAULT_LIGHT_SETTINGS } from '@shared/stores/appStore'
 
@@ -142,16 +144,67 @@ interface MeshModelProps {
   onStats: (stats: { vertices: number; triangles: number }) => void
   onSelect: () => void
   onObject: (obj: THREE.Object3D | null) => void
+  onClips: (clips: MotionClip[]) => void
+  clipIndex: number
 }
 
-function MeshModel({ url, jobId, viewMode, selected, onStats, onSelect, onObject }: MeshModelProps): JSX.Element {
+function MeshModel({ url, jobId, viewMode, selected, onStats, onSelect, onObject, onClips, clipIndex }: MeshModelProps): JSX.Element {
   const extension = url.split('?')[0]?.split('.').pop()?.toLowerCase()
-  const common = { url, jobId, viewMode, selected, onStats, onSelect, onObject }
+  const common = { url, jobId, viewMode, selected, onStats, onSelect, onObject, onClips, clipIndex }
   return extension === 'obj' ? <ObjMeshModel {...common} /> : <GltfMeshModel {...common} />
 }
 
 function GltfMeshModel(props: MeshModelProps): JSX.Element {
-  const { scene } = useGLTF(props.url)
+  const gltf = useGLTF(props.url)
+  const { scene, animations } = gltf
+  const mixerRef  = useRef<THREE.AnimationMixer | null>(null)
+  const actionRef = useRef<THREE.AnimationAction | null>(null)
+  const { onClips, clipIndex } = props
+
+  // Rigged models arrive with one or more clips; without a mixer they render
+  // frozen in bind pose, which reads as "the rig failed". The mixer lives for
+  // as long as this model does — clip switches below reuse it.
+  useEffect(() => {
+    if (!animations?.length) {
+      mixerRef.current = null
+      actionRef.current = null
+      return
+    }
+    const mixer = new THREE.AnimationMixer(scene)
+    mixerRef.current = mixer
+    return () => {
+      mixer.stopAllAction()
+      mixer.uncacheRoot(scene)
+      mixerRef.current = null
+      actionRef.current = null
+    }
+  }, [scene, animations])
+
+  // Tell the viewer which clips are available so it can render the motion bar.
+  useEffect(() => {
+    onClips(animations?.map((clip) => ({ name: clip.name })) ?? [])
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- onClips is a stable callback
+  }, [animations])
+
+  // Switch to the selected clip, cross-fading so playback never hard-cuts.
+  useEffect(() => {
+    const mixer = mixerRef.current
+    if (!mixer || !animations?.length) return
+    const clip = animations[Math.min(clipIndex, animations.length - 1)]
+    const next = mixer.clipAction(clip)
+    next.reset().setLoop(THREE.LoopRepeat, Infinity)
+    const prev = actionRef.current
+    if (prev && prev !== next) {
+      prev.fadeOut(0.25)
+      next.fadeIn(0.25).play()
+    } else {
+      next.play()
+    }
+    actionRef.current = next
+  }, [animations, clipIndex])
+
+  useFrame((_state, delta) => mixerRef.current?.update(delta))
+
   return <SceneMeshModel {...props} scene={scene} loaderType="gltf" />
 }
 
@@ -815,6 +868,20 @@ export default function Viewer3D({ lightSettings = DEFAULT_LIGHT_SETTINGS, gizmo
 
   const [viewMode, setViewMode] = useState<ViewMode>('solid')
   const [autoRotate, setAutoRotate] = useState(false)
+  const clips = useAppStore((s) => s.motionClips)
+  const activeClipIndex = useAppStore((s) => s.activeClipIndex)
+  const setStoreMotionClips = useAppStore((s) => s.setMotionClips)
+  const setStoreActiveClipIndex = useAppStore((s) => s.setActiveClipIndex)
+  // Playback and every selector share appStore. Keeping a local mirror here
+  // made the Library tile and motion bar disagree about the active clip.
+  const setClips = useCallback((c: MotionClip[]) => {
+    setStoreMotionClips(c)
+    const currentIndex = useAppStore.getState().activeClipIndex
+    if (currentIndex >= c.length) setStoreActiveClipIndex(0)
+  }, [setStoreActiveClipIndex, setStoreMotionClips])
+  const setActiveClipIndex = useCallback((i: number) => {
+    setStoreActiveClipIndex(i)
+  }, [setStoreActiveClipIndex])
   const selected = useAppStore((s) => s.meshSelected)
   const setSelected = useAppStore((s) => s.setMeshSelected)
   const canvasRef = useRef<HTMLCanvasElement | null>(null)
@@ -848,6 +915,8 @@ export default function Viewer3D({ lightSettings = DEFAULT_LIGHT_SETTINGS, gizmo
     setSelected(false)
     setViewMode('solid')
     setStoreMeshStats(null)
+    setClips([])
+    setActiveClipIndex(0)
     // eslint-disable-next-line react-hooks/exhaustive-deps -- reset only when the model changes; setters are stable
   }, [modelUrl])
 
@@ -997,6 +1066,8 @@ export default function Viewer3D({ lightSettings = DEFAULT_LIGHT_SETTINGS, gizmo
                   onStats={setStoreMeshStats}
                   onSelect={() => setSelected(true)}
                   onObject={setMeshObject}
+                  onClips={setClips}
+                  clipIndex={activeClipIndex}
                 />
               </Suspense>
             </Selection>
@@ -1043,12 +1114,23 @@ export default function Viewer3D({ lightSettings = DEFAULT_LIGHT_SETTINGS, gizmo
           />
         )}
 
-        {/* Bottom-left stats overlay */}
-        {meshStats && (
-          <div className="absolute bottom-4 left-4 pointer-events-none">
-            <p className="text-xs text-zinc-500">
-              {meshStats.triangles.toLocaleString()} tri &bull; {meshStats.vertices.toLocaleString()} verts
-            </p>
+        {modelUrl && !isSplat && (
+          <LiveTexturePanel
+            key={modelUrl}
+            object={meshObject}
+            onApplied={() => setViewMode('solid')}
+          />
+        )}
+
+        {/* Bottom-left overlays — mesh stats and the motion bar */}
+        {(meshStats || clips.length > 0) && (
+          <div className="absolute bottom-4 left-4 flex flex-col items-start gap-2">
+            {meshStats && (
+              <p className="text-xs text-zinc-500 pointer-events-none">
+                {meshStats.triangles.toLocaleString()} tri &bull; {meshStats.vertices.toLocaleString()} verts
+              </p>
+            )}
+            <MotionBar clips={clips} activeIndex={activeClipIndex} onChange={setActiveClipIndex} />
           </div>
         )}
 
@@ -1066,4 +1148,4 @@ export default function Viewer3D({ lightSettings = DEFAULT_LIGHT_SETTINGS, gizmo
       </div>
     </ModelErrorBoundary>
   )
-}
\ No newline at end of file
+}
diff --git a/src/areas/generate/components/WorkflowPanel.tsx b/src/areas/generate/components/WorkflowPanel.tsx
index ffc774c7..8d9bc653 100644
--- a/src/areas/generate/components/WorkflowPanel.tsx
+++ b/src/areas/generate/components/WorkflowPanel.tsx
@@ -13,9 +13,16 @@ import { useWorkflowRunStore } from '@areas/workflows/workflowRunStore'
 import { useWaitButton } from '@areas/workflows/useWaitButton'
 import { buildAllWorkflowExtensions, getWorkflowExtension } from '@areas/workflows/mockExtensions'
 import { validateWorkflowPreflight } from '@areas/workflows/preflight'
+import { areAllWorkflowNodeParamsBound } from '@areas/workflows/workflowParamBindings'
 import type { WorkflowExtension } from '@areas/workflows/mockExtensions'
 import type { Workflow, WFNode, WFEdge, ParamSchema } from '@shared/types/electron.d'
 import ChatPanel from './ChatPanel'
+import {
+  THIN_PART_SUGGESTION_MESSAGE,
+  applyThinPartSuggestion,
+  getThinPartSuggestion,
+  measureThinPartConfidence,
+} from '../thinPartSuggestion'
 
 type PanelMode = 'basic' | 'chat'
 
@@ -59,6 +66,50 @@ function mimeFromPath(p: string): string {
   return 'image/png'
 }
 
+// ─── Tag suggestions ──────────────────────────────────────────────────────────
+
+const TAG_STOPWORDS = new Set([
+  'a', 'an', 'the', 'of', 'for', 'and', 'or', 'to', 'in', 'on', 'my', 'this', 'is', 'with',
+])
+
+const FIXED_TAG_VOCAB = [
+  'prop', 'character', 'creature', 'environment', 'weapon',
+  'furniture', 'hero-asset', 'background', 'low-poly', 'stylized', 'realistic',
+]
+
+const MAX_TAG_SUGGESTIONS = 10
+
+/** Slugified words pulled from the typed name/project, plus a small fixed vocabulary — capped and deduped. */
+function suggestedTags(modelName: string, project: string): string[] {
+  const fromFields = `${modelName} ${project}`
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((word) => word.length > 1 && !TAG_STOPWORDS.has(word))
+
+  const seen = new Set<string>()
+  const suggestions: string[] = []
+  for (const tag of [...fromFields, ...FIXED_TAG_VOCAB]) {
+    if (!tag || seen.has(tag)) continue
+    seen.add(tag)
+    suggestions.push(tag)
+    if (suggestions.length >= MAX_TAG_SUGGESTIONS) break
+  }
+  return suggestions
+}
+
+function parseTags(value: string): string[] {
+  return value.split(',').map((s) => s.trim()).filter(Boolean)
+}
+
+/** Appends a tag to the comma-separated value, or removes it if already present. */
+function toggleTag(value: string, tag: string): string {
+  const tags = parseTags(value)
+  const i = tags.indexOf(tag)
+  if (i >= 0) tags.splice(i, 1)
+  else tags.push(tag)
+  return tags.join(', ')
+}
+
 // ─── Param field ──────────────────────────────────────────────────────────────
 
 const inputCls = 'w-full bg-zinc-800 border border-zinc-700/80 rounded-md px-2 py-1 text-[11px] text-zinc-200 focus:outline-none focus:border-accent/60'
@@ -116,6 +167,17 @@ function ParamField({ param, value, onChange }: {
   value:    number | string
   onChange: (v: number | string) => void
 }) {
+  if (param.multiline) {
+    return (
+      <textarea
+        value={value as string}
+        placeholder={param.tooltip ?? ''}
+        onChange={(e) => onChange(e.target.value)}
+        rows={5}
+        className={`${inputCls} resize-y min-h-[6rem] leading-relaxed`}
+      />
+    )
+  }
   if (param.type === 'select') {
     return (
       <select value={value} onChange={(e) => onChange(e.target.value)} className={inputCls}>
@@ -141,6 +203,12 @@ function ParamField({ param, value, onChange }: {
       </div>
     )
   }
+  if (param.type === 'text') {
+    return (
+      <input type="text" value={value as string} placeholder={param.tooltip ?? ''}
+        onChange={(e) => onChange(e.target.value)} className={inputCls} />
+    )
+  }
   if (param.type === 'float') {
     return <FloatInput value={value as number} onChange={(v) => onChange(v)} className={inputCls} />
   }
@@ -148,6 +216,37 @@ function ParamField({ param, value, onChange }: {
   return <IntInput value={value as number} onChange={(v) => onChange(v)} className={inputCls} />
 }
 
+function TagSuggestionPills({ value, onChange, modelName, project }: {
+  value:     string
+  onChange:  (v: string) => void
+  modelName: string
+  project:   string
+}) {
+  const suggestions = useMemo(() => suggestedTags(modelName, project), [modelName, project])
+  if (suggestions.length === 0) return null
+
+  const active = new Set(parseTags(value))
+
+  return (
+    <div className="flex flex-wrap gap-1.5">
+      {suggestions.map((tag) => (
+        <button
+          key={tag}
+          type="button"
+          onClick={() => onChange(toggleTag(value, tag))}
+          className={`px-2 py-0.5 rounded-full text-[10px] border transition-colors ${
+            active.has(tag)
+              ? 'bg-accent/20 border-accent/60 text-accent-light'
+              : 'bg-zinc-800 border-zinc-700 text-zinc-400 hover:border-zinc-600 hover:text-zinc-200'
+          }`}
+        >
+          {tag}
+        </button>
+      ))}
+    </div>
+  )
+}
+
 // ─── Workflow dropdown ────────────────────────────────────────────────────────
 
 function WorkflowDropdown({ workflows, value, onChange }: {
@@ -206,10 +305,45 @@ function WorkflowDropdown({ workflows, value, onChange }: {
 
 type PatchFn = (nodeId: string, patch: Record<string, unknown>) => void
 
-function ImageParamRow({ nodeId, nodes, onPatch }: { nodeId: string; nodes: FlowNode[]; onPatch: PatchFn }) {
+type ThinPartUiState =
+  | { kind: 'suggestion'; targetNodeId: string; currentSetting: string }
+  | { kind: 'kept'; settingName: string }
+  | { kind: 'applied' }
+  | { kind: 'error' }
+  | null
+
+const PIPELINE_SETTING_NAMES: Record<string, string> = {
+  '512': 'Quick',
+  '1024': 'Normal',
+  '1024_cascade': 'Careful',
+  '1536_cascade': 'Painstaking',
+}
+
+function reachableNodeIds(sourceNodeId: string, edges: FlowEdge[]): Set<string> {
+  const reachable = new Set<string>()
+  const queue = [sourceNodeId]
+  while (queue.length > 0) {
+    const source = queue.shift()!
+    for (const edge of edges) {
+      if (edge.source !== source || reachable.has(edge.target)) continue
+      reachable.add(edge.target)
+      queue.push(edge.target)
+    }
+  }
+  return reachable
+}
+
+function ImageParamRow({ nodeId, nodes, edges, onPatch }: {
+  nodeId: string
+  nodes: FlowNode[]
+  edges: FlowEdge[]
+  onPatch: PatchFn
+}) {
   const node     = nodes.find((n) => n.id === nodeId)
   const data     = node?.data as { params: Record<string, unknown> } | undefined
   const preview  = data?.params.preview as string | undefined
+  const [thinPartState, setThinPartState] = useState<ThinPartUiState>(null)
+  const checkSequence = useRef(0)
 
   const browse = useCallback(async () => {
     const p = await window.electron.fs.selectImage()
@@ -217,7 +351,53 @@ function ImageParamRow({ nodeId, nodes, onPatch }: { nodeId: string; nodes: Flow
     const base64 = await window.electron.fs.readFileBase64(p)
     const src = `data:${mimeFromPath(p)};base64,${base64}`
     onPatch(nodeId, { params: { ...(data?.params ?? {}), filePath: p, preview: src } })
-  }, [nodeId, data?.params, onPatch])
+    setThinPartState(null)
+
+    const sequence = ++checkSequence.current
+    try {
+      const confidence = await measureThinPartConfidence(src)
+      if (sequence !== checkSequence.current) return
+
+      const reachable = reachableNodeIds(nodeId, edges)
+      const target = nodes.find((candidate) => {
+        if (!reachable.has(candidate.id) || candidate.type !== 'extensionNode') return false
+        const candidateData = candidate.data as { params?: Record<string, unknown> }
+        return typeof candidateData.params?.pipeline_type === 'string'
+      })
+      if (!target) return
+
+      const targetData = target.data as { params: Record<string, unknown> }
+      const currentSetting = String(targetData.params.pipeline_type)
+      if (!getThinPartSuggestion(confidence, currentSetting)) return
+      setThinPartState({
+        kind: 'suggestion',
+        targetNodeId: target.id,
+        currentSetting,
+      })
+    } catch {
+      if (sequence === checkSequence.current) setThinPartState({ kind: 'error' })
+    }
+  }, [nodeId, data?.params, edges, nodes, onPatch])
+
+  const acceptSuggestion = useCallback(() => {
+    if (thinPartState?.kind !== 'suggestion') return
+    const target = nodes.find((candidate) => candidate.id === thinPartState.targetNodeId)
+    const targetData = target?.data as { params?: Record<string, unknown> } | undefined
+    if (!targetData?.params) {
+      setThinPartState({ kind: 'error' })
+      return
+    }
+    onPatch(target.id, { params: applyThinPartSuggestion(targetData.params) })
+    setThinPartState({ kind: 'applied' })
+  }, [nodes, onPatch, thinPartState])
+
+  const declineSuggestion = useCallback(() => {
+    if (thinPartState?.kind !== 'suggestion') return
+    setThinPartState({
+      kind: 'kept',
+      settingName: PIPELINE_SETTING_NAMES[thinPartState.currentSetting] ?? 'current',
+    })
+  }, [thinPartState])
 
   return (
     <div className="flex flex-col gap-1.5">
@@ -226,7 +406,7 @@ function ImageParamRow({ nodeId, nodes, onPatch }: { nodeId: string; nodes: Flow
           <rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="8.5" cy="8.5" r="1.5"/>
           <polyline points="21 15 16 10 5 21"/>
         </svg>
-        <span className="text-[11px] font-medium text-zinc-300">Image</span>
+        <span className="text-[11px] font-medium text-zinc-300">Your sketch or photo — required</span>
       </div>
       {preview ? (
         <button onClick={browse} className="relative w-full aspect-square rounded-lg overflow-hidden border border-zinc-700 group">
@@ -245,6 +425,67 @@ function ImageParamRow({ nodeId, nodes, onPatch }: { nodeId: string; nodes: Flow
           <span className="text-[10px] text-zinc-500">Browse image…</span>
         </button>
       )}
+
+      {thinPartState?.kind === 'suggestion' && (
+        <div
+          role="status"
+          aria-live="polite"
+          className="mt-1 flex flex-col gap-2.5 rounded-lg border border-sky-700/60 bg-sky-950/45 px-3 py-2.5"
+        >
+          <p className="text-[11px] leading-relaxed text-sky-100">
+            {THIN_PART_SUGGESTION_MESSAGE}
+          </p>
+          <div className="flex gap-2">
+            <button
+              type="button"
+              onClick={acceptSuggestion}
+              className="flex-1 rounded-md bg-sky-600 px-2 py-1.5 text-[10px] font-semibold text-white transition-colors hover:bg-sky-500"
+            >
+              Use Careful
+            </button>
+            <button
+              type="button"
+              onClick={declineSuggestion}
+              className="flex-1 rounded-md border border-zinc-600 bg-zinc-800 px-2 py-1.5 text-[10px] font-medium text-zinc-200 transition-colors hover:bg-zinc-700"
+            >
+              Keep {PIPELINE_SETTING_NAMES[thinPartState.currentSetting] ?? 'current setting'}
+            </button>
+          </div>
+          <p className="text-[10px] text-sky-300/80">
+            Optional — you can generate without choosing either button.
+          </p>
+        </div>
+      )}
+
+      {thinPartState?.kind === 'kept' && (
+        <p
+          role="status"
+          aria-live="polite"
+          className="mt-1 rounded-lg border border-zinc-700 bg-zinc-900/70 px-3 py-2 text-[10px] text-zinc-300"
+        >
+          Kept {thinPartState.settingName}. Nothing was changed, and the run is ready whenever you are.
+        </p>
+      )}
+
+      {thinPartState?.kind === 'applied' && (
+        <p
+          role="status"
+          aria-live="polite"
+          className="mt-1 rounded-lg border border-sky-700/50 bg-sky-950/35 px-3 py-2 text-[10px] text-sky-200"
+        >
+          Using Careful — about 1 minute total. File weight and every other setting stayed the same.
+        </p>
+      )}
+
+      {thinPartState?.kind === 'error' && (
+        <p
+          role="alert"
+          className="mt-1 rounded-lg border border-amber-800/60 bg-amber-950/40 px-3 py-2 text-[10px] text-amber-300"
+        >
+          I couldn&apos;t check this image for thin parts. Nothing was changed, and you can still generate.
+        </p>
+      )}
+
     </div>
   )
 }
@@ -323,20 +564,22 @@ function TextParamRow({ nodeId, nodes, onPatch }: { nodeId: string; nodes: FlowN
         <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="#fbbf24" strokeWidth="2">
           <path d="M17 6.1H3M21 12.1H3M15.1 18H3"/>
         </svg>
-        <span className="text-[11px] font-medium text-zinc-300">Text</span>
+        <span className="text-[11px] font-medium text-zinc-300">Extra details — optional</span>
       </div>
       <textarea
         value={text}
         onChange={(e) => onPatch(nodeId, { params: { ...(data?.params ?? {}), text: e.target.value } })}
-        placeholder="Enter text…" rows={3}
-        className="w-full bg-zinc-800 border border-zinc-700/80 rounded-md px-2.5 py-2 text-[11px] text-zinc-200 placeholder-zinc-600 focus:outline-none focus:border-amber-500/40 resize-none leading-relaxed"
+        placeholder="Enter text…" rows={14}
+        className="w-full bg-zinc-800 border border-zinc-700/80 rounded-md px-2.5 py-2 text-[11px] text-zinc-200 placeholder-zinc-600 focus:outline-none focus:border-amber-500/40 resize-y min-h-[14rem] leading-relaxed"
       />
     </div>
   )
 }
 
-function WaitParamRow({ nodeId }: { nodeId: string }) {
+function WaitParamRow({ nodeId, nodes }: { nodeId: string; nodes: FlowNode[] }) {
   const { waitState, canContinue, isRunning, label, buttonClass, onContinue } = useWaitButton(nodeId)
+  const node = nodes.find((candidate) => candidate.id === nodeId)
+  const stepName = String((node?.data as { label?: string } | undefined)?.label ?? 'Continue this workflow')
 
   return (
     <div className="flex flex-col gap-1.5">
@@ -344,7 +587,7 @@ function WaitParamRow({ nodeId }: { nodeId: string }) {
         <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="#71717a" strokeWidth="2">
           <circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/>
         </svg>
-        <span className="text-[11px] font-medium text-zinc-300">Wait</span>
+        <span className="text-[11px] font-medium text-zinc-300">{stepName}</span>
       </div>
       {waitState ? (
         <button
@@ -424,13 +667,27 @@ function ExtensionParamRow({ nodeId, ext, nodes, onPatch }: { nodeId: string; ex
         <div className="mt-2 flex flex-col gap-2">
           {ext.params.map((param) => {
             const val = ((data?.params[param.id] ?? param.default) as number | string)
+            const setValue = (v: number | string) =>
+              onPatch(nodeId, { params: { ...(data?.params ?? {}), [param.id]: v } })
             return (
-              <div key={param.id} className="flex items-center gap-2">
-                <label className="text-[10px] text-zinc-500 w-20 shrink-0 truncate">{param.label}</label>
-                <div className="flex-1">
-                  <ParamField param={param} value={val}
-                    onChange={(v) => onPatch(nodeId, { params: { ...(data?.params ?? {}), [param.id]: v } })} />
+              <div key={param.id} className="flex flex-col gap-1.5">
+                <div className="flex items-center gap-2">
+                  <label className="text-[10px] text-zinc-500 w-32 shrink-0 leading-tight">{param.label}</label>
+                  <div className="flex-1">
+                    <ParamField param={param} value={val} onChange={setValue} />
+                  </div>
                 </div>
+                {param.tooltip && (
+                  <p className="pl-[136px] text-[9px] leading-snug text-zinc-600">{param.tooltip}</p>
+                )}
+                {param.id === 'tags' && (
+                  <TagSuggestionPills
+                    value={String(val)}
+                    onChange={setValue}
+                    modelName={String(data?.params['model_name'] ?? '')}
+                    project={String(data?.params['project'] ?? '')}
+                  />
+                )}
               </div>
             )
           })}
@@ -488,10 +745,15 @@ function EmbeddedCanvas({ workflow, allExtensions }: {
     [nodes, edges],
   )
 
-  const paramNodes = sortedNodes.filter((n) =>
-    (n.type === 'imageNode' || n.type === 'textNode' || n.type === 'meshNode' || n.type === 'extensionNode' || n.type === 'waitNode')
-    && (n.data as { showInGenerate?: boolean }).showInGenerate === true,
-  )
+  const paramNodes = sortedNodes.filter((n) => {
+    if (
+      (n.type !== 'imageNode' && n.type !== 'textNode' && n.type !== 'meshNode' && n.type !== 'extensionNode' && n.type !== 'waitNode')
+      || (n.data as { showInGenerate?: boolean }).showInGenerate !== true
+    ) return false
+    if (n.type !== 'extensionNode') return true
+    const ext = getWorkflowExtension(n.data.extensionId ?? '', allExtensions)
+    return !ext || !areAllWorkflowNodeParamsBound(workflow, n.id, ext.params.map((param) => param.id))
+  })
 
   const handleGenerate = useCallback(() => {
     if (firstPreflightIssue) {
@@ -518,10 +780,10 @@ function EmbeddedCanvas({ workflow, allExtensions }: {
           const isLast = i === paramNodes.length - 1
           return (
             <div key={node.id}>
-              {node.type === 'imageNode' && <ImageParamRow nodeId={node.id} nodes={nodes} onPatch={patchNode} />}
+              {node.type === 'imageNode' && <ImageParamRow nodeId={node.id} nodes={nodes} edges={edges} onPatch={patchNode} />}
               {node.type === 'textNode'  && <TextParamRow  nodeId={node.id} nodes={nodes} onPatch={patchNode} />}
               {node.type === 'meshNode'  && <MeshParamRow  nodeId={node.id} nodes={nodes} onPatch={patchNode} />}
-              {node.type === 'waitNode'  && <WaitParamRow  nodeId={node.id} />}
+              {node.type === 'waitNode'  && <WaitParamRow  nodeId={node.id} nodes={nodes} />}
               {node.type === 'extensionNode' && (() => {
                 const ext = getWorkflowExtension(node.data.extensionId ?? '', allExtensions)
                 return ext ? <ExtensionParamRow nodeId={node.id} ext={ext} nodes={nodes} onPatch={patchNode} /> : null
diff --git a/src/areas/generate/components/liveTexture.test.ts b/src/areas/generate/components/liveTexture.test.ts
new file mode 100644
index 00000000..5b1f027b
--- /dev/null
+++ b/src/areas/generate/components/liveTexture.test.ts
@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import * as THREE from 'three'
+
+import {
+  findLiveTextureTarget,
+  prepareLiveTexture,
+  replaceLiveTexture,
+} from './liveTexture.ts'
+
+function texture(width = 2, height = 2): THREE.DataTexture {
+  return new THREE.DataTexture(new Uint8Array(width * height * 4), width, height)
+}
+
+test('finds one shared painted texture and replaces every material that uses it', () => {
+  const original = texture()
+  const first = new THREE.MeshBasicMaterial({ map: original })
+  const second = new THREE.MeshBasicMaterial({ map: original })
+  const group = new THREE.Group()
+  group.add(
+    new THREE.Mesh(new THREE.BoxGeometry(), first),
+    new THREE.Mesh(new THREE.BoxGeometry(), second),
+  )
+
+  const found = findLiveTextureTarget(group)
+  assert.equal(found.ok, true)
+  if (!found.ok) return
+  assert.equal(found.target.width, 2)
+  assert.equal(found.target.height, 2)
+  assert.equal(found.target.materials.length, 2)
+
+  original.flipY = false
+  original.wrapS = THREE.RepeatWrapping
+  original.wrapT = THREE.MirroredRepeatWrapping
+  const replacement = texture()
+  prepareLiveTexture(replacement, original)
+  replaceLiveTexture(found.target, replacement)
+
+  assert.equal(first.map, replacement)
+  assert.equal(second.map, replacement)
+  assert.equal(replacement.flipY, false)
+  assert.equal(replacement.wrapS, THREE.RepeatWrapping)
+  assert.equal(replacement.wrapT, THREE.MirroredRepeatWrapping)
+  assert.equal(replacement.magFilter, THREE.NearestFilter)
+  assert.equal(replacement.minFilter, THREE.NearestFilter)
+  assert.equal(replacement.generateMipmaps, false)
+  assert.equal(replacement.colorSpace, THREE.SRGBColorSpace)
+})
+
+test('fails visibly when a model has more than one painted texture', () => {
+  const group = new THREE.Group()
+  group.add(
+    new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshBasicMaterial({ map: texture() })),
+    new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshBasicMaterial({ map: texture() })),
+  )
+
+  const found = findLiveTextureTarget(group)
+  assert.equal(found.ok, false)
+  if (found.ok) return
+  assert.match(found.message, /more than one painted texture/)
+})
diff --git a/src/areas/generate/components/liveTexture.ts b/src/areas/generate/components/liveTexture.ts
new file mode 100644
index 00000000..8e6d68c4
--- /dev/null
+++ b/src/areas/generate/components/liveTexture.ts
@@ -0,0 +1,99 @@
+import * as THREE from 'three'
+
+type PaintedMaterial = THREE.Material & { map: THREE.Texture | null }
+
+export interface LiveTextureTarget {
+  texture: THREE.Texture
+  materials: PaintedMaterial[]
+  width: number
+  height: number
+}
+
+export type LiveTextureTargetResult =
+  | { ok: true; target: LiveTextureTarget }
+  | { ok: false; message: string }
+
+function materialList(value: THREE.Material | THREE.Material[]): THREE.Material[] {
+  return Array.isArray(value) ? value : [value]
+}
+
+function hasPaintedTexture(material: THREE.Material): material is PaintedMaterial {
+  return 'map' in material && material.map instanceof THREE.Texture
+}
+
+function textureSize(texture: THREE.Texture): { width: number; height: number } | null {
+  const image = texture.image as { width?: unknown; height?: unknown } | undefined
+  const width = Number(image?.width)
+  const height = Number(image?.height)
+  return Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0
+    ? { width, height }
+    : null
+}
+
+export function findLiveTextureTarget(object: THREE.Object3D): LiveTextureTargetResult {
+  const materials = new Set<PaintedMaterial>()
+  const textures = new Set<THREE.Texture>()
+
+  object.traverse((child) => {
+    if (!(child instanceof THREE.Mesh)) return
+    const original = child.userData.originalMaterial as THREE.Material | THREE.Material[] | undefined
+    const source = original ?? child.material
+    for (const material of materialList(source)) {
+      if (!hasPaintedTexture(material) || !material.map) continue
+      materials.add(material)
+      textures.add(material.map)
+    }
+  })
+
+  if (textures.size === 0) {
+    return { ok: false, message: 'This model has no painted texture to update.' }
+  }
+  if (textures.size > 1) {
+    return {
+      ok: false,
+      message: 'This model uses more than one painted texture. Live updates currently work with one texture at a time.',
+    }
+  }
+
+  const texture = [...textures][0]
+  const size = textureSize(texture)
+  if (!size) {
+    return { ok: false, message: 'The model texture size could not be read.' }
+  }
+
+  return {
+    ok: true,
+    target: {
+      texture,
+      materials: [...materials].filter((material) => material.map === texture),
+      width: size.width,
+      height: size.height,
+    },
+  }
+}
+
+export function prepareLiveTexture(texture: THREE.Texture, source: THREE.Texture): void {
+  texture.name = source.name
+  texture.wrapS = source.wrapS
+  texture.wrapT = source.wrapT
+  texture.flipY = source.flipY
+  texture.channel = source.channel
+  texture.offset.copy(source.offset)
+  texture.repeat.copy(source.repeat)
+  texture.center.copy(source.center)
+  texture.rotation = source.rotation
+  texture.matrixAutoUpdate = source.matrixAutoUpdate
+  texture.matrix.copy(source.matrix)
+  texture.colorSpace = THREE.SRGBColorSpace
+  texture.magFilter = THREE.NearestFilter
+  texture.minFilter = THREE.NearestFilter
+  texture.generateMipmaps = false
+  texture.needsUpdate = true
+}
+
+export function replaceLiveTexture(target: LiveTextureTarget, texture: THREE.Texture): void {
+  for (const material of target.materials) {
+    material.map = texture
+    material.needsUpdate = true
+  }
+}
diff --git a/src/areas/generate/thinPartSuggestion.test.mjs b/src/areas/generate/thinPartSuggestion.test.mjs
new file mode 100644
index 00000000..7b617774
--- /dev/null
+++ b/src/areas/generate/thinPartSuggestion.test.mjs
@@ -0,0 +1,49 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { buildSync } from 'esbuild'
+import { createRequire } from 'node:module'
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+function loadModule() {
+  const outfile = join(mkdtempSync(join(tmpdir(), 'modly-thin-suggestion-test-')), 'suggestion.cjs')
+  const require = createRequire(import.meta.url)
+  const result = buildSync({
+    entryPoints: [resolve('src/areas/generate/thinPartSuggestion.ts')],
+    bundle: true,
+    platform: 'node',
+    format: 'cjs',
+    write: false,
+  })
+  writeFileSync(outfile, result.outputFiles[0].text, 'utf8')
+  return require(outfile)
+}
+
+test('the known squid false-positive band stays quiet', () => {
+  const { getThinPartSuggestion } = loadModule()
+  assert.equal(getThinPartSuggestion(0.955102, '1024'), null)
+  assert.equal(getThinPartSuggestion(0.969999, '1024'), null)
+})
+
+test('the confirmed fan band proposes Careful without applying it', () => {
+  const { getThinPartSuggestion } = loadModule()
+  const currentParams = { pipeline_type: '1024', faces: 30_000, seed: 7 }
+  const suggestion = getThinPartSuggestion(0.972787, currentParams.pipeline_type)
+  assert.equal(suggestion.proposedSetting, '1024_cascade')
+  assert.deepEqual(currentParams, { pipeline_type: '1024', faces: 30_000, seed: 7 })
+})
+
+test('accepting changes only study time and leaves file weight alone', () => {
+  const { applyThinPartSuggestion } = loadModule()
+  const currentParams = { pipeline_type: '1024', faces: 30_000, seed: 7 }
+  const accepted = applyThinPartSuggestion(currentParams)
+  assert.deepEqual(accepted, { pipeline_type: '1024_cascade', faces: 30_000, seed: 7 })
+  assert.deepEqual(currentParams, { pipeline_type: '1024', faces: 30_000, seed: 7 })
+})
+
+test('already-careful settings do not prompt again', () => {
+  const { getThinPartSuggestion } = loadModule()
+  assert.equal(getThinPartSuggestion(1, '1024_cascade'), null)
+  assert.equal(getThinPartSuggestion(1, '1536_cascade'), null)
+})
diff --git a/src/areas/generate/thinPartSuggestion.ts b/src/areas/generate/thinPartSuggestion.ts
new file mode 100644
index 00000000..e476d3af
--- /dev/null
+++ b/src/areas/generate/thinPartSuggestion.ts
@@ -0,0 +1,233 @@
+export const MIN_THIN_PART_SUGGESTION_CONFIDENCE = 0.97
+export const CAREFUL_PIPELINE_SETTING = '1024_cascade'
+
+export const THIN_PART_SUGGESTION_MESSAGE =
+  'This looks like it has thin parts, such as blades, wires, or tentacles. ' +
+  'Those can come out shredded at the normal setting. Use the Careful setting? ' +
+  'It takes about 1 minute total instead of about 25 seconds.'
+
+export interface ThinPartSuggestion {
+  confidence: number
+  proposedSetting: typeof CAREFUL_PIPELINE_SETTING
+}
+
+const PIPELINE_ORDER: Record<string, number> = {
+  '512': 0,
+  '1024': 1,
+  '1024_cascade': 2,
+  '1536_cascade': 3,
+}
+
+/**
+ * The threshold is deliberately narrow and conservative. In the actual
+ * renderer, the false-positive squid sketch scored 0.955102 and the confirmed
+ * fan photo scored 0.972787. The score is not a probability and disagreed
+ * across lamp crops, so even a qualifying result is only ever offered.
+ */
+export function getThinPartSuggestion(
+  confidence: number,
+  currentSetting: string,
+): ThinPartSuggestion | null {
+  if (!Number.isFinite(confidence) || confidence < MIN_THIN_PART_SUGGESTION_CONFIDENCE) return null
+  if ((PIPELINE_ORDER[currentSetting] ?? PIPELINE_ORDER[CAREFUL_PIPELINE_SETTING]) >= PIPELINE_ORDER[CAREFUL_PIPELINE_SETTING]) {
+    return null
+  }
+  return {
+    confidence,
+    proposedSetting: CAREFUL_PIPELINE_SETTING,
+  }
+}
+
+export function applyThinPartSuggestion(
+  currentParams: Record<string, unknown>,
+): Record<string, unknown> {
+  return {
+    ...currentParams,
+    pipeline_type: CAREFUL_PIPELINE_SETTING,
+  }
+}
+
+function clamp(value: number): number {
+  return Math.max(0, Math.min(1, value))
+}
+
+function periodicStrength(values: number[], minimumOrder = 3, maximumOrder = 12): number {
+  const total = values.reduce((sum, value) => sum + value, 0)
+  if (total <= 0) return 0
+  const mean = total / values.length
+  const centered = values.map((value) => value - mean)
+  const absolute = centered.reduce((sum, value) => sum + Math.abs(value), 0)
+  if (absolute <= 1e-9) return 0
+
+  let best = 0
+  for (let order = minimumOrder; order <= maximumOrder; order += 1) {
+    let real = 0
+    let imaginary = 0
+    for (let index = 0; index < centered.length; index += 1) {
+      const angle = -2 * Math.PI * order * index / centered.length
+      real += centered[index] * Math.cos(angle)
+      imaginary += centered[index] * Math.sin(angle)
+    }
+    best = Math.max(best, Math.hypot(real, imaginary) / absolute)
+  }
+  return best
+}
+
+function projectionRepetition(edges: Uint8Array, width: number, height: number): number {
+  const rows = new Array<number>(height).fill(0)
+  const columns = new Array<number>(width).fill(0)
+  for (let index = 0; index < edges.length; index += 1) {
+    if (!edges[index]) continue
+    const y = Math.floor(index / width)
+    const x = index % width
+    rows[y] += 1
+    columns[x] += 1
+  }
+
+  const autocorrelation = (values: number[]): number => {
+    const mean = values.reduce((sum, value) => sum + value, 0) / Math.max(1, values.length)
+    const centered = values.map((value) => value - mean)
+    const energy = centered.reduce((sum, value) => sum + value * value, 0)
+    if (energy <= 1e-9) return 0
+    const lower = Math.max(3, Math.floor(values.length / 40))
+    const upper = Math.max(lower + 1, Math.floor(values.length / 5))
+    let best = 0
+    for (let lag = lower; lag < upper; lag += 1) {
+      let overlap = 0
+      for (let index = 0; index < values.length - lag; index += 1) {
+        overlap += centered[index] * centered[index + lag]
+      }
+      best = Math.max(best, overlap / energy)
+    }
+    return clamp(best)
+  }
+
+  return Math.max(autocorrelation(rows), autocorrelation(columns))
+}
+
+/**
+ * Browser equivalent of thinfeatures.py's Pillow measurement. The detector
+ * measures edge density plus radial or parallel repetition; it never changes
+ * settings itself.
+ */
+export function scoreThinPartPixels(
+  rgba: Uint8ClampedArray,
+  width: number,
+  height: number,
+): number {
+  if (width < 32 || height < 32) throw new Error(`Image is too small to check (${width}×${height}).`)
+  if (rgba.length !== width * height * 4) throw new Error('Image pixels could not be read.')
+
+  const grey = new Uint8ClampedArray(width * height)
+  for (let index = 0; index < grey.length; index += 1) {
+    const offset = index * 4
+    grey[index] = Math.round(
+      0.299 * rgba[offset] +
+      0.587 * rgba[offset + 1] +
+      0.114 * rgba[offset + 2],
+    )
+  }
+
+  // Pillow's FIND_EDGES kernel: eight neighbours at -1, centre at 8.
+  const edgeValues = new Uint8ClampedArray(width * height)
+  for (let y = 1; y < height - 1; y += 1) {
+    for (let x = 1; x < width - 1; x += 1) {
+      const index = y * width + x
+      let value = grey[index] * 8
+      for (let offsetY = -1; offsetY <= 1; offsetY += 1) {
+        for (let offsetX = -1; offsetX <= 1; offsetX += 1) {
+          if (offsetX === 0 && offsetY === 0) continue
+          value -= grey[(y + offsetY) * width + x + offsetX]
+        }
+      }
+      edgeValues[index] = Math.max(0, Math.min(255, Math.round(value)))
+    }
+  }
+
+  const interior: number[] = []
+  for (let y = 2; y < height - 2; y += 1) {
+    for (let x = 2; x < width - 2; x += 1) {
+      interior.push(edgeValues[y * width + x])
+    }
+  }
+  interior.sort((a, b) => a - b)
+  const median = interior[Math.floor(interior.length / 2)]
+  const threshold = Math.max(22, median + 18)
+  const edges = new Uint8Array(width * height)
+  let activeCount = 0
+  let activeTotal = 0
+  for (let y = 2; y < height - 2; y += 1) {
+    for (let x = 2; x < width - 2; x += 1) {
+      const index = y * width + x
+      if (edgeValues[index] < threshold) continue
+      edges[index] = 1
+      activeCount += 1
+      activeTotal += edgeValues[index]
+    }
+  }
+
+  const interiorCount = Math.max(1, (width - 4) * (height - 4))
+  const edgeFraction = activeCount / interiorCount
+  const edgeEnergy = activeTotal / Math.max(1, interiorCount * 255)
+
+  const centerX = (width - 1) * 0.5
+  const centerY = (height - 1) * 0.5
+  const maximumRadius = Math.min(width, height) * 0.48
+  const minimumRadius = maximumRadius * 0.16
+  const angular = new Array<number>(72).fill(0)
+  for (let index = 0; index < edges.length; index += 1) {
+    if (!edges[index]) continue
+    const y = Math.floor(index / width)
+    const x = index % width
+    const dx = x - centerX
+    const dy = y - centerY
+    const radius = Math.hypot(dx, dy)
+    if (radius < minimumRadius || radius > maximumRadius) continue
+    const angle = (Math.atan2(dy, dx) + Math.PI) / (2 * Math.PI)
+    const slot = Math.min(angular.length - 1, Math.floor(angle * angular.length))
+    angular[slot] += 1
+  }
+  const smoothedAngular = angular.map((_, index) =>
+    (
+      angular[(index - 1 + angular.length) % angular.length] +
+      angular[index] +
+      angular[(index + 1) % angular.length]
+    ) / 3,
+  )
+  const radialRepetition = periodicStrength(smoothedAngular)
+  const parallelRepetition = projectionRepetition(edges, width, height)
+  const repetition = Math.max(radialRepetition, parallelRepetition)
+
+  const fineScore = clamp((edgeFraction - 0.035) / 0.15)
+  const energyScore = clamp((edgeEnergy - 0.012) / 0.075)
+  const detail = Math.max(fineScore, energyScore)
+  let score = clamp(0.48 * detail + 0.52 * clamp((repetition - 0.08) / 0.42))
+  if (detail < 0.18 || repetition < 0.12) score *= 0.55
+  return Math.round(score * 1_000_000) / 1_000_000
+}
+
+function loadImage(src: string): Promise<HTMLImageElement> {
+  return new Promise((resolve, reject) => {
+    const image = new Image()
+    image.onload = () => resolve(image)
+    image.onerror = () => reject(new Error('The selected image could not be checked.'))
+    image.src = src
+  })
+}
+
+export async function measureThinPartConfidence(src: string): Promise<number> {
+  const image = await loadImage(src)
+  const scale = Math.min(1, 384 / image.naturalWidth, 384 / image.naturalHeight)
+  const width = Math.max(1, Math.round(image.naturalWidth * scale))
+  const height = Math.max(1, Math.round(image.naturalHeight * scale))
+  const canvas = document.createElement('canvas')
+  canvas.width = width
+  canvas.height = height
+  const context = canvas.getContext('2d', { willReadFrequently: true })
+  if (!context) throw new Error('The selected image could not be checked.')
+  context.imageSmoothingEnabled = true
+  context.imageSmoothingQuality = 'high'
+  context.drawImage(image, 0, 0, width, height)
+  const pixels = context.getImageData(0, 0, width, height)
+  return scoreThinPartPixels(pixels.data, width, height)
+}
diff --git a/src/areas/settings/components/AccessibilitySection.tsx b/src/areas/settings/components/AccessibilitySection.tsx
index 423e6335..8dc5de47 100644
--- a/src/areas/settings/components/AccessibilitySection.tsx
+++ b/src/areas/settings/components/AccessibilitySection.tsx
@@ -1,8 +1,8 @@
-import { useAppStore } from '@shared/stores/appStore'
-import { Section, Card, Row, Toggle, SegmentedControl } from '@shared/ui'
+import { useAppStore, UI_ZOOM_PRESETS } from '@shared/stores/appStore'
+import { Section, Card, Row, Toggle } from '@shared/ui'
 
 export function AccessibilitySection(): JSX.Element {
-  const { useAtkinsonFont, setUseAtkinsonFont, uiScale, setUiScale } = useAppStore()
+  const { useAtkinsonFont, setUseAtkinsonFont, uiZoomFactor, setUiZoomFactor } = useAppStore()
 
   return (
     <Section title="Accessibility" subtitle="Make Modly easier to read and use.">
@@ -19,20 +19,31 @@ export function AccessibilitySection(): JSX.Element {
 
         <Card title="Interface Scale" description="Zoom the whole interface up or down.">
           <Row
-            label="Scale"
-            description="Applies to all text, icons, and spacing."
+            label={`Scale — ${Math.round(uiZoomFactor * 100)}%`}
+            description="Applies to all text, icons and spacing, and is kept when you restart. Ctrl or Cmd with + and - changes it too, in smaller steps; Ctrl or Cmd with 0 returns to 100%."
           >
-            <SegmentedControl
-              ariaLabel="Interface scale"
-              value={uiScale}
-              onChange={setUiScale}
-              options={[
-                { value: 'small',      label: 'Small'      },
-                { value: 'medium',     label: 'Medium'     },
-                { value: 'large',      label: 'Large'      },
-                { value: 'very-large', label: 'Very Large' },
-              ]}
-            />
+            {/* Buttons rather than a four-way switch: the keyboard shortcut can
+                land between the presets, and a switch would have to lie about
+                which one is selected. The percentage above always tells the
+                truth. */}
+            <div className="flex gap-1" role="group" aria-label="Interface scale">
+              {UI_ZOOM_PRESETS.map(({ label, factor }) => (
+                <button
+                  key={label}
+                  type="button"
+                  onClick={() => setUiZoomFactor(factor)}
+                  aria-pressed={Math.abs(uiZoomFactor - factor) < 0.005}
+                  className={
+                    'px-2 py-1 text-xs rounded border transition-colors ' +
+                    (Math.abs(uiZoomFactor - factor) < 0.005
+                      ? 'border-violet-500 text-violet-300 bg-violet-500/10'
+                      : 'border-neutral-700 text-neutral-400 hover:text-neutral-200')
+                  }
+                >
+                  {label}
+                </button>
+              ))}
+            </div>
           </Row>
         </Card>
 
diff --git a/src/areas/workflows/mergeNodeText.test.ts b/src/areas/workflows/mergeNodeText.test.ts
new file mode 100644
index 00000000..a8fc4fd7
--- /dev/null
+++ b/src/areas/workflows/mergeNodeText.test.ts
@@ -0,0 +1,49 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mergeNodeText } from './mergeNodeText'
+
+const CREATURE =
+  'A photographic creature, rounded volumetric body, limbs curling in depth, ' +
+  'wet specular skin, dark studio background.'
+const NOTE =
+  'Keep the left tentacle shorter than the others; preserve the inked eye rings exactly.'
+
+test('the artist note is added to the style, not swapped for it', () => {
+  const merged = mergeNodeText(CREATURE, NOTE)
+  assert.ok(merged.includes('photographic creature'), 'style direction survives')
+  assert.ok(merged.includes('left tentacle shorter'), 'artist note survives')
+})
+
+test('this is the exact run that came out flat', () => {
+  // Before the fix the generator received only the note — a description of a
+  // drawing — and made a flat card. The regression this file guards.
+  const merged = mergeNodeText(CREATURE, NOTE)
+  assert.notEqual(merged, NOTE)
+})
+
+test('a Custom style carries no direction, so the note is the whole prompt', () => {
+  assert.equal(mergeNodeText('', NOTE), NOTE)
+  assert.equal(mergeNodeText(undefined, NOTE), NOTE)
+})
+
+test('no note leaves the style untouched', () => {
+  assert.equal(mergeNodeText(CREATURE, ''), CREATURE)
+  assert.equal(mergeNodeText(CREATURE, '   '), CREATURE)
+})
+
+test('nothing is said twice', () => {
+  assert.equal(mergeNodeText(NOTE, NOTE), NOTE)
+  assert.equal(mergeNodeText(`${CREATURE} ${NOTE}`, NOTE), `${CREATURE} ${NOTE}`)
+})
+
+test('one sentence break between them, however the style was punctuated', () => {
+  assert.equal(mergeNodeText('Low poly.', 'Red.'), 'Low poly. Red.')
+  assert.equal(mergeNodeText('Low poly', 'Red.'), 'Low poly. Red.')
+  assert.equal(mergeNodeText('Low poly.   ', 'Red.'), 'Low poly. Red.')
+})
+
+test('non-string params are tolerated rather than crashing a run', () => {
+  assert.equal(mergeNodeText(null, NOTE), NOTE)
+  assert.equal(mergeNodeText(42, NOTE), NOTE)
+  assert.equal(mergeNodeText(CREATURE, null), CREATURE)
+})
diff --git a/src/areas/workflows/mergeNodeText.ts b/src/areas/workflows/mergeNodeText.ts
new file mode 100644
index 00000000..0cc02b6a
--- /dev/null
+++ b/src/areas/workflows/mergeNodeText.ts
@@ -0,0 +1,26 @@
+/**
+ * Combine a step's own art direction with the free text an artist typed into
+ * "Extra details".
+ *
+ * The note ADDS TO the direction; it never replaces it. This used to replace
+ * it, silently, and it was expensive: choosing a Creature style and then asking
+ * to keep one tentacle short deleted every word about being a photographic
+ * creature, so the generator was handed a cropped notebook drawing and
+ * faithfully rebuilt it as a flat card. Weeks of the flatness were blamed on
+ * resolution and mesh budgets; the cause was this line.
+ *
+ * `base` is unknown rather than string because it comes from a params bag that
+ * may hold anything, or nothing at all — a Custom style deliberately carries an
+ * empty prompt so the artist's own words are the whole direction.
+ */
+export function mergeNodeText(base: unknown, added: unknown): string {
+  const direction = typeof base === 'string' ? base.trim() : ''
+  const note = typeof added === 'string' ? added.trim() : ''
+  if (!note) return direction
+  if (!direction) return note
+  // Already said — don't stutter it back at the generator. Keep the DIRECTION,
+  // which is the longer text: collapsing to the note here would throw away the
+  // style again, which is the whole failure this function exists to prevent.
+  if (direction === note || direction.includes(note)) return direction
+  return `${direction.replace(/[.\s]+$/, '')}. ${note}`
+}
diff --git a/src/areas/workflows/nodes/ExtensionNode.tsx b/src/areas/workflows/nodes/ExtensionNode.tsx
index a9703290..6a199c7a 100644
--- a/src/areas/workflows/nodes/ExtensionNode.tsx
+++ b/src/areas/workflows/nodes/ExtensionNode.tsx
@@ -304,11 +304,16 @@ export default function ExtensionNode({ id, data, selected }: { id: string; data
             return ext!.params.filter(isVisible).map((param) => {
               const val = (data.params[param.id] ?? param.default) as number | string
               return (
-                <div key={param.id} className="flex items-center gap-2">
-                  <label className="text-[10px] text-zinc-500 w-24 shrink-0 leading-tight">{param.label}</label>
-                  <div className="flex-1">
-                    <ParamControl param={param} value={val} onChange={(v) => patchParam(param.id, v)} resolvedParams={resolvedParams} />
+                <div key={param.id} className="flex flex-col gap-1">
+                  <div className="flex items-center gap-2">
+                    <label className="text-[10px] text-zinc-500 w-24 shrink-0 leading-tight">{param.label}</label>
+                    <div className="flex-1">
+                      <ParamControl param={param} value={val} onChange={(v) => patchParam(param.id, v)} resolvedParams={resolvedParams} />
+                    </div>
                   </div>
+                  {param.tooltip && (
+                    <p className="pl-[104px] text-[9px] leading-snug text-zinc-600">{param.tooltip}</p>
+                  )}
                 </div>
               )
             })
diff --git a/src/areas/workflows/nodes/WaitNode.tsx b/src/areas/workflows/nodes/WaitNode.tsx
index 3f3dff72..a01c51b4 100644
--- a/src/areas/workflows/nodes/WaitNode.tsx
+++ b/src/areas/workflows/nodes/WaitNode.tsx
@@ -38,7 +38,7 @@ export default function WaitNode({ id, data, selected }: { id: string; data: WFN
     <BaseNode
       id={id}
       selected={selected}
-      title="Wait"
+      title={String(data.label ?? 'Continue this workflow')}
       minWidth={170}
       showInGenerate={data.showInGenerate ?? false}
       icon={
diff --git a/src/areas/workflows/nodes/intent-travel/manifest.json b/src/areas/workflows/nodes/intent-travel/manifest.json
new file mode 100644
index 00000000..027d8e04
--- /dev/null
+++ b/src/areas/workflows/nodes/intent-travel/manifest.json
@@ -0,0 +1,25 @@
+{
+  "id": "intent-travel",
+  "name": "Artist Context",
+  "type": "process",
+  "entry": "processor.js",
+  "version": "1.0.0",
+  "author": "Modly",
+  "description": "Carries the artist's exact request alongside every workflow asset.",
+  "nodes": [
+    {
+      "id": "start",
+      "name": "Remember Artist Context",
+      "input": "image",
+      "output": "image",
+      "params_schema": []
+    },
+    {
+      "id": "carry",
+      "name": "Carry Artist Context",
+      "input": "mesh",
+      "output": "mesh",
+      "params_schema": []
+    }
+  ]
+}
diff --git a/src/areas/workflows/nodes/intent-travel/processor.ts b/src/areas/workflows/nodes/intent-travel/processor.ts
new file mode 100644
index 00000000..12908a26
--- /dev/null
+++ b/src/areas/workflows/nodes/intent-travel/processor.ts
@@ -0,0 +1,263 @@
+import crypto = require('crypto')
+import fs     = require('fs')
+import path   = require('path')
+
+interface ProcessInput {
+  filePath?: string
+  text?: string
+  nodeId?: string
+}
+
+interface ProcessResult {
+  filePath?: string
+}
+
+interface ProcessContext {
+  workspaceDir: string
+  progress:     (pct: number, label: string) => void
+}
+
+interface IntentContext {
+  sourceImage?: string | null
+  project?: string | null
+  extraDetails?: string | null
+  movement?: string | null
+  styleName?: string | null
+  stylePrompt?: string | null
+  workflowId?: string | null
+  workflowName?: string | null
+}
+
+type JsonObject = Record<string, unknown>
+
+const SCHEMA = 'modly.intent.v1'
+const APPEND_ONLY_LISTS = ['artist_words', 'style_choices', 'findings', 'stage_events'] as const
+
+function now(): string {
+  return new Date().toISOString()
+}
+
+function entry(kind: string, fields: JsonObject = {}): JsonObject {
+  return { id: crypto.randomUUID(), kind, at: now(), ...fields }
+}
+
+function sidecarPath(assetPath: string): string {
+  return assetPath.replace(/\.[^./\\]+$/, '') + '.tags.json'
+}
+
+function readObject(filePath: string, missingOk: boolean): JsonObject {
+  if (!fs.existsSync(filePath)) {
+    if (missingOk) return {}
+    throw new Error(`Artist context is missing: ${filePath}`)
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+  } catch (error) {
+    throw new Error(`Artist context cannot be read from ${filePath}: ${String(error)}`)
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`Artist context is not a JSON object: ${filePath}`)
+  }
+  return parsed as JsonObject
+}
+
+function writeObjectAtomic(filePath: string, value: JsonObject): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(value, null, 2) + '\n', 'utf-8')
+    fs.renameSync(temporary, filePath)
+  } finally {
+    if (fs.existsSync(temporary)) fs.unlinkSync(temporary)
+  }
+}
+
+function nonEmpty(value: unknown): string | null {
+  if (typeof value !== 'string') return null
+  const text = value.trim()
+  return text.length > 0 ? text : null
+}
+
+function requireIntent(sidecar: JsonObject, assetPath: string): JsonObject {
+  const intent = sidecar.intent
+  if (!intent || typeof intent !== 'object' || Array.isArray(intent)) {
+    throw new Error(`Artist context is missing beside ${assetPath}`)
+  }
+  const record = intent as JsonObject
+  if (record.schema !== SCHEMA || typeof record.intent_id !== 'string') {
+    throw new Error(`Artist context beside ${assetPath} has an unsupported format`)
+  }
+  for (const key of APPEND_ONLY_LISTS) {
+    if (!Array.isArray(record[key])) {
+      throw new Error(`Artist context beside ${assetPath} has no ${key} history`)
+    }
+  }
+  if (!record.request || typeof record.request !== 'object' || Array.isArray(record.request)) {
+    throw new Error(`Artist context beside ${assetPath} has no request`)
+  }
+  return JSON.parse(JSON.stringify(record)) as JsonObject
+}
+
+function word(kind: 'movement' | 'context', text: string, source: string): JsonObject {
+  return entry(kind, { text, source, origin: 'artist' })
+}
+
+function startRecord(assetPath: string, context: IntentContext): void {
+  const metadataPath = sidecarPath(assetPath)
+  const sidecar = readObject(metadataPath, true)
+  if (sidecar.intent) {
+    throw new Error(`Refusing to replace artist context in ${metadataPath}`)
+  }
+
+  const extraDetails = nonEmpty(context.extraDetails)
+  const movement = nonEmpty(context.movement)
+  const styleName = nonEmpty(context.styleName)
+  const stylePrompt = nonEmpty(context.stylePrompt)
+  const project = nonEmpty(context.project)
+  const words: JsonObject[] = []
+  if (movement) words.push(word('movement', movement, 'request.movement'))
+  if (extraDetails) words.push(word('context', extraDetails, 'request.extra_details'))
+  const movementWord = words.find((row) => row.kind === 'movement')
+  const created = now()
+  const record: JsonObject = {
+    schema: SCHEMA,
+    intent_id: crypto.randomUUID(),
+    created_at: created,
+    updated_at: created,
+    request: {
+      what_word_id: null,
+      movement_word_id: movementWord?.id ?? null,
+      source_image: nonEmpty(context.sourceImage),
+      project,
+    },
+    artist_words: words,
+    style_choices: styleName || stylePrompt
+      ? [entry('style', {
+          stage: 'request',
+          name: styleName,
+          prompt: stylePrompt,
+        })]
+      : [],
+    findings: [],
+    stage_events: [
+      entry('created', {
+        stage: 'request',
+        asset: assetPath,
+        note: 'Artist request captured',
+        workflow: {
+          id: nonEmpty(context.workflowId),
+          name: nonEmpty(context.workflowName),
+        },
+      }),
+    ],
+  }
+  sidecar.intent = record
+  if (sidecar.project == null) sidecar.project = project
+  writeObjectAtomic(metadataPath, sidecar)
+}
+
+function rows(record: JsonObject, key: typeof APPEND_ONLY_LISTS[number]): JsonObject[] {
+  return (record[key] as JsonObject[]).map((row) => JSON.parse(JSON.stringify(row)) as JsonObject)
+}
+
+function mergeIntent(older: JsonObject, newer: JsonObject): JsonObject {
+  if (older.intent_id !== newer.intent_id) {
+    throw new Error('Cannot merge artist context from different requests')
+  }
+  if (JSON.stringify(older.request) !== JSON.stringify(newer.request)) {
+    throw new Error('Copies of the artist request disagree')
+  }
+  const merged = JSON.parse(JSON.stringify(newer)) as JsonObject
+  for (const key of APPEND_ONLY_LISTS) {
+    const byId = new Map<string, JsonObject>()
+    for (const row of [...rows(older, key), ...rows(newer, key)]) {
+      const id = nonEmpty(row.id)
+      if (!id) throw new Error(`Artist context ${key} entry has no id`)
+      const prior = byId.get(id)
+      if (prior && JSON.stringify(prior) !== JSON.stringify(row)) {
+        throw new Error(`Artist context ${key} entry ${id} has conflicting contents`)
+      }
+      if (!prior) byId.set(id, row)
+    }
+    merged[key] = [...byId.values()]
+  }
+  merged.created_at = String(older.created_at) < String(newer.created_at)
+    ? older.created_at
+    : newer.created_at
+  merged.updated_at = String(older.updated_at) > String(newer.updated_at)
+    ? older.updated_at
+    : newer.updated_at
+  return merged
+}
+
+function carryRecord(sourceAsset: string, destinationAsset: string, params: JsonObject): void {
+  const sourceSidecar = readObject(sidecarPath(sourceAsset), false)
+  const sourceIntent = requireIntent(sourceSidecar, sourceAsset)
+  const destinationPath = sidecarPath(destinationAsset)
+  const destination = readObject(destinationPath, true)
+  destination.intent = destination.intent
+    ? mergeIntent(requireIntent(destination, destinationAsset), sourceIntent)
+    : sourceIntent
+
+  const carried = destination.intent as JsonObject
+  ;(carried.stage_events as JsonObject[]).push(entry('carried', {
+    stage: nonEmpty(params.stage) ?? 'unknown',
+    from_asset: sourceAsset,
+    to_asset: destinationAsset,
+    details: params.details && typeof params.details === 'object' ? params.details : {},
+  }))
+  carried.updated_at = now()
+  if (destination.project == null) {
+    const request = carried.request as JsonObject
+    destination.project = sourceSidecar.project ?? request.project ?? null
+  }
+  writeObjectAtomic(destinationPath, destination)
+}
+
+function stageSource(input: ProcessInput, params: JsonObject, context: ProcessContext): string {
+  const originalPath = nonEmpty(input.filePath)
+  const encoded = nonEmpty(input.text)
+  if (!originalPath && !encoded) {
+    throw new Error('Artist context needs the source image')
+  }
+
+  const suffix = originalPath ? (path.extname(originalPath) || '.png') : '.png'
+  const runDir = path.join(context.workspaceDir, 'Workflows', 'intent-sources', crypto.randomUUID())
+  fs.mkdirSync(runDir, { recursive: true })
+  const staged = path.join(runDir, `source${suffix}`)
+  if (originalPath) {
+    if (!fs.existsSync(originalPath)) throw new Error(`Source image does not exist: ${originalPath}`)
+    fs.copyFileSync(originalPath, staged)
+  } else {
+    const base64 = encoded!.includes(';base64,') ? encoded!.split(';base64,', 2)[1] : encoded!
+    fs.writeFileSync(staged, Buffer.from(base64, 'base64'))
+  }
+  startRecord(staged, (params.context ?? {}) as IntentContext)
+  return staged
+}
+
+const processor = async (
+  input: ProcessInput,
+  params: JsonObject,
+  context: ProcessContext,
+): Promise<ProcessResult> => {
+  if (input.nodeId === 'start') {
+    context.progress(20, 'Remembering your request…')
+    const staged = stageSource(input, params, context)
+    context.progress(100, 'Request remembered')
+    return { filePath: staged }
+  }
+
+  const source = nonEmpty(input.filePath)
+  const destination = nonEmpty(params.destinationPath)
+  if (!source || !destination) {
+    throw new Error('Carrying artist context needs both stage input and output')
+  }
+  context.progress(50, 'Carrying artist context…')
+  carryRecord(source, destination, params)
+  context.progress(100, 'Artist context carried')
+  return { filePath: destination }
+}
+
+export = processor
diff --git a/src/areas/workflows/nodes/mesh-exporter/manifest.json b/src/areas/workflows/nodes/mesh-exporter/manifest.json
index 20eb7a86..82b0e645 100644
--- a/src/areas/workflows/nodes/mesh-exporter/manifest.json
+++ b/src/areas/workflows/nodes/mesh-exporter/manifest.json
@@ -13,6 +13,27 @@
       "input": "mesh",
       "output": "mesh",
       "params_schema": [
+        {
+          "id": "model_name",
+          "label": "Name this model (optional)",
+          "type": "text",
+          "default": "",
+          "description": "Used for the file name, e.g. 'brass floor lamp' becomes brass-floor-lamp-4f2a.glb. Leave it blank for a dated name."
+        },
+        {
+          "id": "project",
+          "label": "Which game or project is this for? (optional)",
+          "type": "text",
+          "default": "",
+          "description": "Files are filed under a folder of this name, so the Library groups a game's models together instead of one long list."
+        },
+        {
+          "id": "tags",
+          "label": "Tags (optional, comma separated)",
+          "type": "text",
+          "default": "",
+          "description": "Saved with the model. The exporter adds what it can tell on its own — rigged, animated, textured, how heavy it is."
+        },
         {
           "id": "export_format",
           "label": "Export Format",
diff --git a/src/areas/workflows/nodes/mesh-exporter/processor.ts b/src/areas/workflows/nodes/mesh-exporter/processor.ts
index 4c188561..d1e077bf 100644
--- a/src/areas/workflows/nodes/mesh-exporter/processor.ts
+++ b/src/areas/workflows/nodes/mesh-exporter/processor.ts
@@ -1,7 +1,7 @@
 import path = require('path')
 import fs   = require('fs')
 
-interface ProcessInput  { filePath?: string; text?: string }
+interface ProcessInput  { filePath?: string; text?: string; sourceAssetPath?: string }
 interface ProcessResult { filePath?: string; text?: string }
 interface ProcessContext {
   workspaceDir: string
@@ -10,6 +10,113 @@ interface ProcessContext {
   progress:     (pct: number, label: string) => void
 }
 
+// ─── Lineage ──────────────────────────────────────────────────────────────────
+// When the input mesh traces back to an existing workspace asset, record where
+// it came from: the immediate parent, plus the root of the chain (so re-exporting
+// an already-derived model doesn't grow an unbounded ancestry list).
+
+interface DerivedRef  { path: string; name: string | null }
+interface DerivedFrom { parent: DerivedRef; root: DerivedRef }
+type Sidecar = Record<string, unknown>
+
+function sidecarPathFor(assetPath: string): string {
+  return assetPath.replace(/\.[^./\\]+$/, '') + '.tags.json'
+}
+
+function readSidecar(assetPath: string): Sidecar {
+  const sidecarPath = sidecarPathFor(assetPath)
+  if (!fs.existsSync(sidecarPath)) return {}
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(fs.readFileSync(sidecarPath, 'utf-8'))
+  } catch (error) {
+    throw new Error(`mesh-exporter: cannot read metadata sidecar ${sidecarPath}: ${String(error)}`)
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`mesh-exporter: metadata sidecar is not a JSON object: ${sidecarPath}`)
+  }
+  return parsed as Sidecar
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : []
+}
+
+function writeSidecarAtomic(assetPath: string, sidecar: Sidecar): void {
+  const destination = sidecarPathFor(assetPath)
+  const temporary = `${destination}.${process.pid}.${Date.now()}.tmp`
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(sidecar, null, 2) + '\n', 'utf-8')
+    fs.renameSync(temporary, destination)
+  } finally {
+    if (fs.existsSync(temporary)) fs.unlinkSync(temporary)
+  }
+}
+
+/** Workspace-relative form of an absolute path, or null if it's outside the workspace. */
+function toWorkspaceRelative(workspaceDir: string, absPath: string): string | null {
+  const norm   = absPath.replace(/\\/g, '/')
+  const wsNorm = workspaceDir.replace(/\\/g, '/').replace(/\/+$/, '')
+  if (norm !== wsNorm && !norm.startsWith(wsNorm + '/')) return null
+  return norm.slice(wsNorm.length + 1)
+}
+
+/** Reads asset.extras.modly straight out of a GLB's leading JSON chunk — used only
+ *  as a name fallback when a source asset predates the .tags.json sidecar. */
+function readGlbModlyExtras(glbPath: string): { name?: string } | null {
+  try {
+    const fd = fs.openSync(glbPath, 'r')
+    try {
+      const header = Buffer.alloc(12)
+      fs.readSync(fd, header, 0, 12, 0)
+      if (header.toString('ascii', 0, 4) !== 'glTF') return null
+      const chunkHeader = Buffer.alloc(8)
+      fs.readSync(fd, chunkHeader, 0, 8, 12)
+      const chunkLength = chunkHeader.readUInt32LE(0)
+      if (chunkHeader.toString('ascii', 4, 8) !== 'JSON') return null
+      const chunkData = Buffer.alloc(chunkLength)
+      fs.readSync(fd, chunkData, 0, chunkLength, 20)
+      const json = JSON.parse(chunkData.toString('utf-8'))
+      return json?.asset?.extras?.modly ?? null
+    } finally {
+      fs.closeSync(fd)
+    }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Resolves the `derived_from` sidecar field for an export whose input traces
+ * back to `sourceAssetPath`. Returns null when there's nothing to record (no
+ * source, or the source isn't a workspace asset).
+ */
+function resolveDerivedFrom(sourceAssetPath: string | undefined, workspaceDir: string): DerivedFrom | null {
+  if (!sourceAssetPath) return null
+  const relPath = toWorkspaceRelative(workspaceDir, sourceAssetPath)
+  if (!relPath) return null
+
+  let name: string | null = null
+  let upstream: DerivedFrom | undefined
+
+  const sidecarPath = sidecarPathFor(sourceAssetPath)
+  if (fs.existsSync(sidecarPath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(sidecarPath, 'utf-8'))
+      name = data.name ?? null
+      if (data.derived_from) upstream = data.derived_from as DerivedFrom
+    } catch {
+      // Malformed sidecar — treat the source as untagged rather than failing the export.
+    }
+  } else {
+    name = readGlbModlyExtras(sourceAssetPath)?.name ?? null
+  }
+
+  const parent: DerivedRef = { path: relPath, name }
+  const root = upstream?.root ?? parent
+  return { parent, root }
+}
+
 // ─── Geometry extraction ──────────────────────────────────────────────────────
 
 interface PrimGeometry {
@@ -200,16 +307,94 @@ const processor = async (
   context.progress(20, 'Loading mesh…')
   const doc = await io.read(input.filePath)
 
-  let outPath: string
-  if (outputPath) {
-    fs.mkdirSync(outputPath, { recursive: true })
-    outPath = path.join(outputPath, `export-${Date.now()}${ext}`)
-  } else {
-    const exportsDir = path.join(context.workspaceDir, 'Exports')
-    fs.mkdirSync(exportsDir, { recursive: true })
-    outPath = path.join(exportsDir, `export-${Date.now()}${ext}`)
+  // modly-friendly-names: a folder of export-1785194887022.glb tells you nothing.
+  const stamp  = new Date()
+  const pad    = (n: number): string => String(n).padStart(2, '0')
+  const unique = Date.now().toString(36).slice(-4)
+  const typed  = String(params['model_name'] ?? '').trim()
+  const slug   = typed
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48)
+  const dated = `model-${stamp.getFullYear()}-${pad(stamp.getMonth() + 1)}-${pad(stamp.getDate())}`
+    + `-${pad(stamp.getHours())}${pad(stamp.getMinutes())}`
+  const baseName = `${slug || dated}-${unique}${ext}`
+
+  const slugify = (s: unknown): string => String(s ?? '').toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40)
+  const project = slugify(params['project'])
+
+  const root = outputPath || path.join(context.workspaceDir, 'Exports')
+  const dir  = project ? path.join(root, project) : root
+  fs.mkdirSync(dir, { recursive: true })
+  const outPath = path.join(dir, baseName)
+
+  // Tags: what the operator typed, plus what the file itself can tell us.
+  const typedTags = String(params['tags'] ?? '').split(',').map(slugify).filter(Boolean)
+  const suggested: string[] = []
+  try {
+    const r = doc.getRoot()
+    if (r.listSkins().length) suggested.push('rigged')
+    if (r.listAnimations().length) {
+      suggested.push('animated')
+      for (const a of r.listAnimations()) {
+        const n = slugify(a.getName())
+        if (n) suggested.push(`clip-${n}`)
+      }
+    }
+    if (r.listTextures().length) suggested.push('textured')
+    let tris = 0
+    for (const m of r.listMeshes())
+      for (const prim of m.listPrimitives()) {
+        const idx = prim.getIndices()
+        tris += idx ? idx.getCount() / 3
+                    : (prim.getAttribute('POSITION')?.getCount() ?? 0) / 3
+      }
+    tris = Math.round(tris)
+    suggested.push(tris < 5000 ? 'low-poly' : tris > 100000 ? 'high-poly' : 'mid-poly')
+    if (project) suggested.push(project)
+  } catch (e) {
+    context.log(`tagging skipped: ${e}`)
+  }
+  const sourceSidecar = readSidecar(input.filePath)
+  const tags = Array.from(new Set([
+    ...stringArray(sourceSidecar.tags),
+    ...typedTags,
+    ...suggested,
+  ]))
+
+  // Lineage: only recorded when the input actually traces back to an existing
+  // workspace asset — a fresh generation has nothing to chain to.
+  const derivedFrom = resolveDerivedFrom(input.sourceAssetPath, context.workspaceDir)
+  const existingOutputSidecar = readSidecar(outPath)
+  const outputSidecar: Sidecar = {
+    // Preserve the complete traveling record and any future metadata fields.
+    // The exporter owns only the catalog fields below.
+    ...sourceSidecar,
+    ...existingOutputSidecar,
+    name:    typed || existingOutputSidecar.name || sourceSidecar.name || null,
+    project: params['project'] || existingOutputSidecar.project || sourceSidecar.project || null,
+    tags: Array.from(new Set([
+      ...stringArray(existingOutputSidecar.tags),
+      ...tags,
+    ])),
+    ...(derivedFrom
+      ? { derived_from: derivedFrom }
+      : (existingOutputSidecar.derived_from ?? sourceSidecar.derived_from)
+        ? { derived_from: existingOutputSidecar.derived_from ?? sourceSidecar.derived_from }
+        : {}),
+    created: existingOutputSidecar.created || new Date().toISOString(),
+  }
+
+  try {
+    const asset = doc.getRoot().getAsset()
+    asset.extras = Object.assign({}, asset.extras, {
+      modly: { name: typed || null, project: params['project'] || null, tags },
+    })
+  } catch (e) {
+    context.log(`could not embed tags: ${e}`)
   }
-  fs.mkdirSync(path.dirname(outPath), { recursive: true })
 
   context.progress(50, `Exporting as ${format.toUpperCase()}…`)
 
@@ -223,6 +408,10 @@ const processor = async (
     else if (format === 'ply') writePLY(prims, outPath)
   }
 
+  // Publish metadata only after the asset exists. This also prevents a failed
+  // conversion from leaving a catalog entry that points at no model.
+  writeSidecarAtomic(outPath, outputSidecar)
+
   context.progress(100, 'Done')
   context.log(`Output: ${outPath}`)
   return { filePath: outPath }
diff --git a/src/areas/workflows/nodes/mesh-optimizer/manifest.json b/src/areas/workflows/nodes/mesh-optimizer/manifest.json
index 1b13004e..b2924164 100644
--- a/src/areas/workflows/nodes/mesh-optimizer/manifest.json
+++ b/src/areas/workflows/nodes/mesh-optimizer/manifest.json
@@ -15,12 +15,14 @@
       "params_schema": [
         {
           "id": "target_faces",
-          "label": "Target Triangles",
-          "type": "int",
-          "default": 10000,
-          "min": 100,
-          "max": 1000000,
-          "tooltip": "Target number of triangles after simplification."
+          "label": "Detail",
+          "type": "select",
+          "default": 1000000,
+          "options": [
+            { "value": 1000000, "label": "Full detail (unchanged)" },
+            { "value": 50000, "label": "Game prop (about 50,000 triangles)" },
+            { "value": 10000, "label": "Background piece (about 10,000 triangles)" }
+          ]
         }
       ]
     }
diff --git a/src/areas/workflows/nodes/mesh-optimizer/processor.ts b/src/areas/workflows/nodes/mesh-optimizer/processor.ts
index f6f16d4e..1fcb0d85 100644
--- a/src/areas/workflows/nodes/mesh-optimizer/processor.ts
+++ b/src/areas/workflows/nodes/mesh-optimizer/processor.ts
@@ -9,6 +9,8 @@ interface ProcessContext {
   progress:     (pct: number, label: string) => void
 }
 
+const KEEP_FULL_DETAIL = 1_000_000
+
 const processor = async (
   input:   ProcessInput,
   params:  Record<string, unknown>,
@@ -16,7 +18,18 @@ const processor = async (
 ): Promise<ProcessResult> => {
   if (!input.filePath) throw new Error('mesh-optimizer: input.filePath is required')
 
-  const targetFaces = Math.max(100, Math.round(Number(params['target_faces'] ?? 10000)))
+  const requestedTargetFaces = Number(params['target_faces'] ?? KEEP_FULL_DETAIL)
+  if (!Number.isFinite(requestedTargetFaces)) {
+    throw new Error('mesh-optimizer: target_faces must be a number')
+  }
+
+  const targetFaces = Math.max(100, Math.round(requestedTargetFaces))
+  if (targetFaces >= KEEP_FULL_DETAIL) {
+    context.log('Full detail selected — skipping simplification')
+    context.progress(100, 'Done')
+    return { filePath: input.filePath }
+  }
+
   context.log(`Target: ${targetFaces} triangles — input: ${input.filePath}`)
 
   // Lazy requires — resolved from the extension's own node_modules
diff --git a/src/areas/workflows/useWaitButton.ts b/src/areas/workflows/useWaitButton.ts
index 873eba97..f50f4e11 100644
--- a/src/areas/workflows/useWaitButton.ts
+++ b/src/areas/workflows/useWaitButton.ts
@@ -37,15 +37,15 @@ export function useWaitButton(nodeId: string): WaitButtonModel {
     : 'bg-amber-500/15 border-amber-500/30 text-amber-400 hover:bg-amber-500/25'
 
   const statusText =
-    waitState === 'blocked' ? 'Waiting for the previous Wait to finish…' :
-    waitState === 'running' ? 'Branch in progress…' :
-    waitState === 'done'    ? 'Branch finished — Retry to re-run.' :
-    waitState === 'error'   ? 'Branch failed — Retry to re-run.' :
-    waitState === 'pending' && runAborted ? 'Run failed upstream — fix the error and run again.' :
-    waitState === 'pending' && inPrePhase ? 'Waiting for upstream nodes…' :
-    waitState === 'pending' && otherBranchRunning ? 'Another branch is running…' :
-    waitState === 'pending' ? 'Workflow paused — click Continue to run this branch.' :
-    'Pauses the workflow until you click Continue.'
+    waitState === 'blocked' ? 'Waiting for the previous step to finish…' :
+    waitState === 'running' ? 'This step is running…' :
+    waitState === 'done'    ? 'This step finished. Retry runs it again without remaking earlier results.' :
+    waitState === 'error'   ? 'This step stopped. Fix the answer or setting, then click Retry.' :
+    waitState === 'pending' && runAborted ? 'An earlier step stopped. Fix that error and start again.' :
+    waitState === 'pending' && inPrePhase ? 'Waiting for earlier steps…' :
+    waitState === 'pending' && otherBranchRunning ? 'Another step is running…' :
+    waitState === 'pending' ? 'Ready. Click Continue to run this step.' :
+    'Click Continue when you are ready for this step.'
 
   return { waitState, canContinue, isRunning, label, buttonClass, statusText, onContinue: () => continueRun(nodeId) }
 }
diff --git a/src/areas/workflows/workflowParamBindings.test.mjs b/src/areas/workflows/workflowParamBindings.test.mjs
new file mode 100644
index 00000000..4f182c44
--- /dev/null
+++ b/src/areas/workflows/workflowParamBindings.test.mjs
@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import {
+  areAllWorkflowNodeParamsBound,
+  resolveBoundWorkflowParams,
+} from './workflowParamBindings.ts'
+
+const workflow = {
+  id: 'asset',
+  name: 'Asset',
+  description: '',
+  createdAt: '',
+  updatedAt: '',
+  nodes: [],
+  edges: [],
+  paramBindings: [{
+    sourceNodeId: 'generate',
+    sourceParam: 'faces',
+    targetNodeId: 'optimize',
+    targetParam: 'target_faces',
+  }],
+}
+
+test('bound params read the source value at target execution time', () => {
+  const live = new Map([
+    ['generate', { faces: 60_000 }],
+    ['optimize', { target_faces: 1_000_000 }],
+  ])
+
+  assert.deepEqual(
+    resolveBoundWorkflowParams(workflow, 'optimize', live.get('optimize'), (nodeId) => live.get(nodeId)),
+    { target_faces: 60_000 },
+  )
+
+  live.set('generate', { faces: 12_000 })
+  assert.deepEqual(
+    resolveBoundWorkflowParams(workflow, 'optimize', live.get('optimize'), (nodeId) => live.get(nodeId)),
+    { target_faces: 12_000 },
+  )
+})
+
+test('unbound params remain unchanged and only fully bound nodes disappear from Generate', () => {
+  const params = { target_faces: 1_000_000, preserve_uvs: true }
+  assert.equal(resolveBoundWorkflowParams(workflow, 'export', params, () => undefined), params)
+  assert.equal(areAllWorkflowNodeParamsBound(workflow, 'optimize', ['target_faces']), true)
+  assert.equal(areAllWorkflowNodeParamsBound(workflow, 'optimize', ['target_faces', 'preserve_uvs']), false)
+  assert.equal(areAllWorkflowNodeParamsBound(workflow, 'generate', ['faces']), false)
+})
diff --git a/src/areas/workflows/workflowParamBindings.ts b/src/areas/workflows/workflowParamBindings.ts
new file mode 100644
index 00000000..b8cc6801
--- /dev/null
+++ b/src/areas/workflows/workflowParamBindings.ts
@@ -0,0 +1,42 @@
+import type { Workflow } from '../../shared/types/electron.d'
+
+type ReadNodeParams = (nodeId: string) => Record<string, unknown> | undefined
+
+/**
+ * Applies declarative cross-node parameter bindings without mutating either
+ * node. The target reads the source's freshest live value when it starts, so
+ * paused and looping workflows keep the same single source of truth.
+ */
+export function resolveBoundWorkflowParams(
+  workflow: Workflow,
+  targetNodeId: string,
+  targetParams: Record<string, unknown>,
+  readNodeParams: ReadNodeParams,
+): Record<string, unknown> {
+  const bindings = workflow.paramBindings?.filter((binding) => binding.targetNodeId === targetNodeId) ?? []
+  if (bindings.length === 0) return targetParams
+
+  const resolved = { ...targetParams }
+  for (const binding of bindings) {
+    const sourceParams = readNodeParams(binding.sourceNodeId)
+    if (sourceParams && Object.prototype.hasOwnProperty.call(sourceParams, binding.sourceParam)) {
+      resolved[binding.targetParam] = sourceParams[binding.sourceParam]
+    }
+  }
+  return resolved
+}
+
+/** A fully bound node has no independent questions to show in Generate. */
+export function areAllWorkflowNodeParamsBound(
+  workflow: Workflow,
+  nodeId: string,
+  paramIds: string[],
+): boolean {
+  if (paramIds.length === 0) return false
+  const boundParams = new Set(
+    (workflow.paramBindings ?? [])
+      .filter((binding) => binding.targetNodeId === nodeId)
+      .map((binding) => binding.targetParam),
+  )
+  return paramIds.every((paramId) => boundParams.has(paramId))
+}
diff --git a/src/areas/workflows/workflowRunStore.ts b/src/areas/workflows/workflowRunStore.ts
index 1e687193..1713cfbc 100644
--- a/src/areas/workflows/workflowRunStore.ts
+++ b/src/areas/workflows/workflowRunStore.ts
@@ -5,6 +5,8 @@ import { getWorkflowExtension } from './mockExtensions'
 import type { WorkflowExtension } from './mockExtensions'
 import type { Workflow, WFNode, WFEdge } from '@shared/types/electron.d'
 import { isBranchStarter, isSceneOutput, resolveDataSource, reachesSceneOutput, nearestUpstreamWaits } from './nodeBehaviors'
+import { resolveBoundWorkflowParams } from './workflowParamBindings'
+import { mergeNodeText } from './mergeNodeText'
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -44,7 +46,143 @@ function flushResume(): void {
   if (fn) fn()
 }
 
-interface NodeOutput { filePath?: string; text?: string; outputType?: string }
+interface NodeOutput {
+  filePath?: string
+  text?:     string
+  outputType?: string
+  /** Absolute path of the existing workspace asset this output traces back to
+   *  (if any) — propagated unchanged from whatever node first resolved it, so a
+   *  mesh-exporter several hops downstream can still record lineage. */
+  sourceAssetPath?: string
+}
+
+interface ArtistIntentContext {
+  sourceImage:  string | null
+  project:      string | null
+  extraDetails: string | null
+  movement:     string | null
+  styleName:    string | null
+  stylePrompt:  string | null
+  workflowId:   string
+  workflowName: string
+}
+
+const INTENT_EXTENSION_ID = 'intent-travel'
+
+function textValue(value: unknown): string | null {
+  return typeof value === 'string' && value.trim().length > 0 ? value : null
+}
+
+function buildArtistIntentContext(
+  workflow: Workflow,
+  allExtensions: WorkflowExtension[],
+  sourceImage: string | undefined,
+): ArtistIntentContext {
+  const paramsFor = (node: WFNode): Record<string, unknown> =>
+    _liveParams.current.get(node.id) ?? node.data.params ?? {}
+
+  const extraNode = workflow.nodes.find((node) =>
+    node.type === 'textNode'
+    && String(node.data.label ?? '').toLowerCase().includes('extra detail'),
+  )
+  const movementNode = workflow.nodes.find((node) =>
+    node.type === 'extensionNode'
+    && (
+      String(node.data.extensionId ?? '').startsWith('rig-and-animate/')
+      || Object.prototype.hasOwnProperty.call(paramsFor(node), 'describe')
+    ),
+  )
+  const styleNode = workflow.nodes.find((node) => {
+    if (node.type !== 'extensionNode') return false
+    const ext = getWorkflowExtension(node.data.extensionId ?? '', allExtensions)
+    return ext?.params.some((param) => param.id === 'prompt' && param.type === 'select') ?? false
+  })
+  const exportNode = workflow.nodes.find((node) =>
+    node.type === 'extensionNode'
+    && String(node.data.extensionId ?? '').startsWith('mesh-exporter/'),
+  )
+
+  const styleParams = styleNode ? paramsFor(styleNode) : {}
+  const stylePrompt = textValue(styleParams.prompt)
+  const styleExt = styleNode
+    ? getWorkflowExtension(styleNode.data.extensionId ?? '', allExtensions)
+    : undefined
+  const styleOption = styleExt?.params
+    .find((param) => param.id === 'prompt')
+    ?.options?.find((option) => String(option.value) === String(styleParams.prompt ?? ''))
+  const styleName = textValue(styleOption?.label)
+
+  let project = textValue(exportNode ? paramsFor(exportNode).project : null)
+  if (!project && styleName?.includes(' · ')) {
+    const candidate = styleName.split(' · ', 1)[0].trim()
+    if (candidate && candidate.toLowerCase() !== 'universal') project = candidate
+  }
+
+  return {
+    sourceImage: sourceImage ?? null,
+    project,
+    extraDetails: textValue(extraNode ? paramsFor(extraNode).text : null),
+    movement: textValue(movementNode ? paramsFor(movementNode).describe : null),
+    styleName,
+    stylePrompt,
+    workflowId: workflow.id,
+    workflowName: workflow.name,
+  }
+}
+
+async function startArtistIntent(
+  workflow: Workflow,
+  allExtensions: WorkflowExtension[],
+  sourcePath: string | undefined,
+  sourceData: string | undefined,
+): Promise<string | undefined> {
+  if (!sourcePath && !sourceData) return undefined
+  const available = allExtensions.some((ext) =>
+    ext.extensionId === INTENT_EXTENSION_ID && ext.nodeId === 'start',
+  )
+  if (!available) {
+    throw new Error('Artist context support is not installed. No generation was started.')
+  }
+  const result = await window.electron.extensions.runProcess(
+    INTENT_EXTENSION_ID,
+    {
+      filePath: sourcePath,
+      text: sourcePath ? undefined : sourceData,
+      nodeId: 'start',
+    },
+    {
+      context: buildArtistIntentContext(workflow, allExtensions, sourcePath),
+    },
+  )
+  if (!result.success || !result.result?.filePath) {
+    throw new Error(result.error ?? 'The artist request could not be recorded. No generation was started.')
+  }
+  return result.result.filePath
+}
+
+async function carryArtistIntent(
+  sourcePath: string,
+  destinationPath: string,
+  node: WFNode,
+  ext: WorkflowExtension,
+): Promise<void> {
+  const result = await window.electron.extensions.runProcess(
+    INTENT_EXTENSION_ID,
+    { filePath: sourcePath, nodeId: 'carry' },
+    {
+      destinationPath,
+      stage: node.data.label ?? ext.name,
+      details: {
+        node_id: node.id,
+        extension_id: node.data.extensionId ?? null,
+        output_type: ext.output ?? null,
+      },
+    },
+  )
+  if (!result.success) {
+    throw new Error(result.error ?? `${ext.name} finished, but the artist context could not be carried`)
+  }
+}
 
 function isSceneMeshOutput(output: NodeOutput | undefined): output is NodeOutput & { filePath: string } {
   return output?.outputType === 'mesh' && typeof output.filePath === 'string'
@@ -137,6 +275,8 @@ interface RunContext {
   iteratorFiles:      Map<string, string[]>
   /** workspace URL of the most recently pushed scene mesh (last branch the user ran wins) */
   lastSceneMesh?:     string
+  /** A run-specific source sidecar was created before the first executable stage. */
+  carriesArtistIntent: boolean
 }
 const _ctx = { current: null as RunContext | null }
 
@@ -298,7 +438,13 @@ async function executeExtensionNode(
   const ext = getWorkflowExtension(node.data.extensionId ?? '', allExtensions)
   // Freshest params at the moment the node starts (so loop iterations / Retry pick
   // up edits made while paused, not the values captured at run start).
-  const liveParams = _liveParams.current.get(node.id) ?? node.data.params ?? {}
+  const nodeParams = _liveParams.current.get(node.id) ?? node.data.params ?? {}
+  const liveParams = resolveBoundWorkflowParams(
+    workflow,
+    node.id,
+    nodeParams,
+    (sourceNodeId) => _liveParams.current.get(sourceNodeId) ?? nodeMap.get(sourceNodeId)?.data.params,
+  )
 
   const resolveSource = (sourceId: string): NodeOutput | undefined => {
     const realId = resolveDataSource(sourceId, workflow.edges, nodeMap)
@@ -308,6 +454,12 @@ async function executeExtensionNode(
   let nodeInputPath:     string | undefined
   let nodeInputText:     string | undefined
   let nodeInputMeshPath: string | undefined
+  // Carries forward whatever existing workspace asset fed this run, however many
+  // hops back — set once at the source (mesh node) and passed through untouched
+  // by every node in between, so mesh-exporter can record lineage even at the
+  // end of a multi-step chain.
+  let nodeInputSourceAssetPath: string | undefined
+  let intentSourcePath: string | undefined
   // Per-slot texts for multi-text-input nodes (e.g. positive/negative prompts).
   // Indexed by target handle: input-0 → texts[0], input-1 → texts[1].
   const nodeInputTexts: (string | undefined)[] = []
@@ -321,6 +473,7 @@ async function executeExtensionNode(
       if (src.outputType === 'mesh')        nodeInputMeshPath = src.filePath
       else if (src.outputType === 'image')  nodeInputPath     = src.filePath
       else if (src.filePath !== undefined)  nodeInputPath     = src.filePath
+      if (src.sourceAssetPath !== undefined) nodeInputSourceAssetPath = src.sourceAssetPath
       if (src.text !== undefined && src.text.trim().length > 0) {
         nodeInputText = src.text
         const slot = /^input-(\d+)$/.exec(edge.targetHandle ?? '')
@@ -331,6 +484,7 @@ async function executeExtensionNode(
     for (const edge of incomingEdges) {
       const src = resolveSource(edge.source)
       if (src?.filePath !== undefined) nodeInputPath = src.filePath
+      if (src?.sourceAssetPath !== undefined) nodeInputSourceAssetPath = src.sourceAssetPath
       if (src?.text !== undefined && src.text.trim().length > 0) nodeInputText = src.text
     }
   }
@@ -340,6 +494,7 @@ async function executeExtensionNode(
   if (isModelNode) {
     const isTextInput = ext?.inputs ? ext.inputs.every((i) => i === 'text') : ext?.input === 'text'
     const activeImagePath = isTextInput ? undefined : (nodeInputPath ?? selectedImagePath)
+    intentSourcePath = nodeInputMeshPath ?? activeImagePath
     if (!isTextInput && !selectedImageData && (!activeImagePath || activeImagePath.trim().length === 0)) {
       throw new Error('No input image selected for model node')
     }
@@ -366,16 +521,20 @@ async function executeExtensionNode(
         ? norm.slice(workspaceDir.length).replace(/^\//, '')
         : norm
     }
-    if (nodeInputText !== undefined && nodeInputText.trim().length > 0) {
-      extraParams.prompt = nodeInputText
-      extraParams.text   = nodeInputText
-    }
 
     const schemaDefaults = Object.fromEntries(
       (ext.params ?? []).map((p) => [p.id, p.default]),
     )
     const effectiveParams = { ...schemaDefaults, ...liveParams }
 
+    // The artist's "Extra details" ADD to the step's own direction rather than
+    // replacing it — see mergeNodeText for what replacing it used to cost.
+    if (nodeInputText !== undefined && nodeInputText.trim().length > 0) {
+      for (const key of ['prompt', 'text'] as const) {
+        extraParams[key] = mergeNodeText(effectiveParams[key], nodeInputText)
+      }
+    }
+
     const fd = new FormData()
     fd.append('image', blob, fname)
     fd.append('model_id', node.data.extensionId ?? '')
@@ -418,6 +577,7 @@ async function executeExtensionNode(
       useAppStore.getState().updateCurrentJob({ status: 'generating', progress: st.progress, step: st.step })
     }
   } else {
+    intentSourcePath = nodeInputMeshPath ?? nodeInputPath
     if (ext?.input === 'mesh'  && !nodeInputPath) throw new Error(`${ext.name} needs an incoming mesh connection`)
     if (ext?.input === 'image' && !nodeInputPath) throw new Error(`${ext.name} needs an incoming image connection`)
     if (ext?.input === 'audio' && !nodeInputPath) throw new Error(`${ext.name} needs an incoming audio connection`)
@@ -433,6 +593,7 @@ async function executeExtensionNode(
         text:     nodeInputText,
         texts:    nodeInputTexts.length > 0 ? nodeInputTexts : undefined,
         nodeId:   nid,
+        sourceAssetPath: nodeInputSourceAssetPath,
       },
       liveParams as Record<string, unknown>,
     )
@@ -443,7 +604,15 @@ async function executeExtensionNode(
   }
 
   const outputType = ext?.output ?? (nodeInputPath ? 'mesh' : undefined)
-  nodeOutputs.set(node.id, { filePath: nodeInputPath, text: nodeInputText, outputType })
+  if (
+    ctx.carriesArtistIntent
+    && intentSourcePath
+    && nodeInputPath
+    && (outputType === 'image' || outputType === 'mesh')
+  ) {
+    await carryArtistIntent(intentSourcePath, nodeInputPath, node, ext!)
+  }
+  nodeOutputs.set(node.id, { filePath: nodeInputPath, text: nodeInputText, outputType, sourceAssetPath: nodeInputSourceAssetPath })
 
   const output = nodeOutputs.get(node.id)
   const url = isSceneMeshOutput(output) ? toWorkspaceUrl(output.filePath, workspaceDir) : undefined
@@ -758,17 +927,42 @@ export const useWorkflowRunStore = create<WorkflowRunStore>((set, get) => {
                 const rel = currentMeshUrl.replace(/^\/workspace\//, '')
                 meshFilePath = `${workspaceDir}/${rel}`
               }
-              nodeOutputs.set(node.id, { filePath: meshFilePath, outputType: 'mesh' })
+              // The loaded scene mesh is itself a workspace asset (or a copy of
+              // one) — track it as the lineage source for anything downstream.
+              nodeOutputs.set(node.id, { filePath: meshFilePath, outputType: 'mesh', sourceAssetPath: meshFilePath })
             } else {
               const fp = node.data.params?.filePath as string | undefined
-              if (fp) nodeOutputs.set(node.id, { filePath: fp, outputType: 'mesh' })
+              if (fp) nodeOutputs.set(node.id, { filePath: fp, outputType: 'mesh', sourceAssetPath: fp })
             }
           }
         }
 
+        // Stage a run-specific copy and create its immutable request record
+        // before the first Style/model step. Reusing the artist's original file
+        // directly would make a second run overwrite the first run's request.
+        const primaryImageNode = ordered.find((node) => node.type === 'imageNode')
+        let carriesArtistIntent = false
+        if (primaryImageNode) {
+          const originalSource = nodeOutputs.get(primaryImageNode.id)?.filePath
+          const stagedSource = await startArtistIntent(
+            workflow,
+            allExtensions,
+            originalSource,
+            originalSource ? undefined : selectedImageData,
+          )
+          if (stagedSource) {
+            nodeOutputs.set(primaryImageNode.id, {
+              filePath: stagedSource,
+              outputType: 'image',
+            })
+            carriesArtistIntent = true
+          }
+        }
+
         const ctx: RunContext = {
           workflow, allExtensions, client, workspaceDir, selectedImagePath, selectedImageData,
           overrideImageData, nodeOutputs, nodeMap, ordered, branches, waitIds, parentWait, iteratorFiles,
+          carriesArtistIntent,
         }
         _ctx.current = ctx
 
@@ -897,7 +1091,7 @@ export const useWorkflowRunStore = create<WorkflowRunStore>((set, get) => {
           // Hand off to the user — branches run on demand via continueRun(id).
           set((s) => ({
             activeNodeId: null,
-            runState: { ...s.runState, status: 'paused', blockStep: 'Pick a branch and click Continue' },
+            runState: { ...s.runState, status: 'paused', blockStep: 'Ready for the next step' },
           }))
           return
         }
@@ -980,7 +1174,7 @@ export const useWorkflowRunStore = create<WorkflowRunStore>((set, get) => {
               ...s.runState,
               status:    allFinished ? 'error' : 'paused',
               error:     anyError ? (err ?? s.runState.error) : undefined,
-              blockStep: err ? `Branch failed: ${err}` : 'Pick a branch and click Continue',
+              blockStep: err ? `This step stopped: ${err}` : 'Ready for the next step',
             },
           }))
         }
diff --git a/src/shared/stores/appStore.ts b/src/shared/stores/appStore.ts
index d06a5211..17a92d0a 100644
--- a/src/shared/stores/appStore.ts
+++ b/src/shared/stores/appStore.ts
@@ -1,7 +1,17 @@
 import { create } from 'zustand'
 import { persist } from 'zustand/middleware'
 
-export type UiScale = 'small' | 'medium' | 'large' | 'very-large'
+/** How much bigger or smaller the whole interface is drawn. 1 is unscaled.
+ *  A number, not a preset name, because Ctrl/Cmd +/- moves it in small steps
+ *  and a four-name list cannot describe where it lands. */
+export const UI_ZOOM_MIN = 0.6
+export const UI_ZOOM_MAX = 2.0
+export const UI_ZOOM_PRESETS = [
+  { label: 'Small',      factor: 0.875 },
+  { label: 'Default',    factor: 1     },
+  { label: 'Large',      factor: 1.25  },
+  { label: 'Very Large', factor: 1.5   },
+]
 export type BackendStatus = 'not_started' | 'starting' | 'ready' | 'error'
 export type SetupStatus = 'idle' | 'checking' | 'needed' | 'installing' | 'done' | 'error'
 export interface SetupProgress { step: string; percent: number; currentPackage?: string }
@@ -25,6 +35,9 @@ export interface GenerationJob {
   modelId?: string             // model used for this generation
   originalTriangles?: number   // polygon count of the original mesh
   generationOptions?: GenerationOptions
+  /** Stable Library identity for the asset currently loaded in the viewer. */
+  libraryEntryId?: string
+  libraryWorkspacePath?: string
   error?: string
   createdAt: number
 }
@@ -101,6 +114,12 @@ interface AppState {
   meshSelected: boolean
   setMeshSelected: (selected: boolean) => void
 
+  // Animation clips (set by Viewer3D, read by ChatPanel for agent context)
+  motionClips: { name: string }[]
+  setMotionClips: (clips: { name: string }[]) => void
+  activeClipIndex: number
+  setActiveClipIndex: (index: number) => void
+
   // Setup
   setupStatus:    SetupStatus
   setupProgress:  SetupProgress | null
@@ -141,8 +160,8 @@ interface AppState {
   // Accessibility
   useAtkinsonFont: boolean
   setUseAtkinsonFont: (v: boolean) => void
-  uiScale: UiScale
-  setUiScale: (v: UiScale) => void
+  uiZoomFactor: number
+  setUiZoomFactor: (v: number) => void
 
   // 3D viewer lighting
   lightSettings: LightSettings
@@ -244,8 +263,9 @@ export const useAppStore = create<AppState>()(
 
       useAtkinsonFont: false,
       setUseAtkinsonFont: (v) => set({ useAtkinsonFont: v }),
-      uiScale: 'medium',
-      setUiScale: (v) => set({ uiScale: v }),
+      uiZoomFactor: 1,
+      setUiZoomFactor: (v) =>
+        set({ uiZoomFactor: Math.min(UI_ZOOM_MAX, Math.max(UI_ZOOM_MIN, v)) }),
 
       lightSettings: DEFAULT_LIGHT_SETTINGS,
       setLightSettings: (settings) => set({ lightSettings: settings }),
@@ -262,6 +282,10 @@ export const useAppStore = create<AppState>()(
       setMeshStats: (stats) => set({ meshStats: stats }),
       meshSelected: false,
       setMeshSelected: (selected) => set({ meshSelected: selected }),
+      motionClips: [],
+      setMotionClips: (clips) => set({ motionClips: clips }),
+      activeClipIndex: 0,
+      setActiveClipIndex: (index) => set({ activeClipIndex: index }),
       initApp: async () => {
         set({ backendStatus: 'starting', backendError: null })
 
@@ -284,7 +308,15 @@ export const useAppStore = create<AppState>()(
         }
       },
 
-      setCurrentJob: (job) => set({ currentJob: job, meshStats: job === null ? null : get().meshStats }),
+      setCurrentJob: (job) => {
+        const changed = job?.id !== get().currentJob?.id
+        set({
+          currentJob: job,
+          meshStats: job === null ? null : get().meshStats,
+          motionClips: changed ? [] : get().motionClips,
+          activeClipIndex: changed ? 0 : get().activeClipIndex,
+        })
+      },
 
       updateCurrentJob: (patch) => {
         const current = get().currentJob
@@ -302,7 +334,7 @@ export const useAppStore = create<AppState>()(
         generationOptions: state.generationOptions,
         showRamIndicator: state.showRamIndicator,
         useAtkinsonFont: state.useAtkinsonFont,
-        uiScale: state.uiScale,
+        uiZoomFactor: state.uiZoomFactor,
         lightSettings: state.lightSettings,
       }),
     }
diff --git a/src/shared/types/assetLibrary.test.ts b/src/shared/types/assetLibrary.test.ts
index 8a6e7494..68753c1d 100644
--- a/src/shared/types/assetLibrary.test.ts
+++ b/src/shared/types/assetLibrary.test.ts
@@ -14,6 +14,8 @@ import type {
   AssetLibraryOpenRequest,
   AssetLibraryReadResult,
   AssetLibrarySourceLink,
+  AssetLibraryThumbnailRequest,
+  AssetLibraryThumbnailResult,
 } from './assetLibrary.ts'
 
 test('declares capability-first asset taxonomy without extension categories', () => {
@@ -27,7 +29,7 @@ test('declares capability-first asset taxonomy without extension categories', ()
   ])
   assert.deepEqual(ASSET_ENTRY_STATES, ['ready', 'unknown-metadata', 'unsupported', 'unsafe'])
   assert.deepEqual(ASSET_LIBRARY_PREVIEW_KINDS, ['3d-model', 'text', 'binary', 'none'])
-  assert.deepEqual(ASSET_LIBRARY_SOURCE_SCOPES, ['workflows', 'exports'])
+  assert.deepEqual(ASSET_LIBRARY_SOURCE_SCOPES, ['generated', 'workflows', 'exports'])
   assert.deepEqual(ASSET_LIBRARY_MANIFEST_CAPABILITIES, ['generated-world', 'scene-manifest'])
   assert.equal((ASSET_CAPABILITIES as readonly string[]).includes('glb'), false)
   assert.equal((ASSET_CAPABILITIES as readonly string[]).includes('splat'), false)
@@ -45,6 +47,16 @@ test('AssetLibraryEntry keeps capability, source scope, provenance, warnings, an
     provenance: { workflowId: 'wf-1', workflowNodeId: 'node-1' },
     warnings: ['Rig metadata was inferred from a sidecar.'],
     openable: true,
+    semantic: {
+      name: 'Hero',
+      project: 'Adventure',
+      tags: ['rigged', 'animated', 'mid-poly'],
+      created: '2026-06-16T10:00:00.000Z',
+      derivedFrom: {
+        parent: { workspacePath: 'Default/hero.glb', displayName: 'Hero' },
+        root: { workspacePath: 'Default/hero.glb', displayName: 'Hero' },
+      },
+    },
   } satisfies AssetLibraryEntry
 
   const list = { success: true, entries: [entry] } satisfies AssetLibraryListResult
@@ -53,6 +65,8 @@ test('AssetLibraryEntry keeps capability, source scope, provenance, warnings, an
   assert.equal(list.entries[0]?.provenance?.workflowId, 'wf-1')
   assert.equal(list.entries[0]?.warnings[0], 'Rig metadata was inferred from a sidecar.')
   assert.equal(list.entries[0]?.openable, true)
+  assert.equal(list.entries[0]?.semantic?.project, 'Adventure')
+  assert.equal(list.entries[0]?.semantic?.derivedFrom?.root.workspacePath, 'Default/hero.glb')
 })
 
 test('structured results preserve renderer-visible error codes and read previews', () => {
@@ -115,6 +129,26 @@ test('AssetLibraryEntry carries library-owned source, manifest, artifact, versio
   assert.equal(entry.provenance?.source, 'library-sidecar')
 })
 
+test('thumbnail requests and results can carry a previewClip name and its clip list', () => {
+  // Typed (not `satisfies`) so the omitted optional `previewClip` is still
+  // part of `staticRequest`'s type instead of narrowing it away entirely.
+  const staticRequest: AssetLibraryThumbnailRequest = { workspacePath: 'Exports/hero.glb' }
+  const clipRequest: AssetLibraryThumbnailRequest = { workspacePath: 'Exports/hero.glb', previewClip: 'walk' }
+  const staticResult = {
+    success: true,
+    dataUrl: 'data:image/png;base64,aa',
+    previews: [{ clip: 'idle', duration: 1.5 }, { clip: 'walk', duration: 0.8 }],
+  } satisfies AssetLibraryThumbnailResult
+  const clipResult = { success: true, dataUrl: 'data:image/webp;base64,bb' } satisfies AssetLibraryThumbnailResult
+  const miss = { success: false } satisfies AssetLibraryThumbnailResult
+
+  assert.equal(staticRequest.previewClip, undefined)
+  assert.equal(clipRequest.previewClip, 'walk')
+  assert.equal(staticResult.previews?.[1]?.clip, 'walk')
+  assert.equal(clipResult.success && clipResult.dataUrl, 'data:image/webp;base64,bb')
+  assert.equal(miss.success, false)
+})
+
 test('read and open requests can carry a sourceWorkspacePath for linked-source opens', () => {
   const request = {
     workspacePath: 'Workflows/checkpoints/hero.landmarks.v1.json',
diff --git a/src/shared/types/assetLibrary.ts b/src/shared/types/assetLibrary.ts
index fb5a602d..5f886891 100644
--- a/src/shared/types/assetLibrary.ts
+++ b/src/shared/types/assetLibrary.ts
@@ -11,7 +11,7 @@ export const ASSET_CAPABILITIES = [
 
 export const ASSET_ENTRY_STATES = ['ready', 'unknown-metadata', 'unsupported', 'unsafe'] as const
 export const ASSET_LIBRARY_PREVIEW_KINDS = ['3d-model', 'text', 'binary', 'none'] as const
-export const ASSET_LIBRARY_SOURCE_SCOPES = ['workflows', 'exports'] as const
+export const ASSET_LIBRARY_SOURCE_SCOPES = ['generated', 'workflows', 'exports'] as const
 export const ASSET_LIBRARY_MANIFEST_CAPABILITIES = ['generated-world', 'scene-manifest'] as const
 
 export type AssetCapability = typeof ASSET_CAPABILITIES[number]
@@ -43,6 +43,32 @@ export interface AssetLibraryEntry {
   nonOpenableReason?: string
   createdAt?: string
   updatedAt?: string
+  semantic?: AssetLibrarySemanticMetadata
+}
+
+export interface AssetLibraryLineageLink {
+  workspacePath: string
+  displayName?: string
+}
+
+export interface AssetLibraryDerivedFrom {
+  /** The asset used directly to create this version. */
+  parent: AssetLibraryLineageLink
+  /** The first asset in the version family. */
+  root: AssetLibraryLineageLink
+}
+
+/**
+ * Human and structural metadata stored beside a model in `<model>.tags.json`.
+ * The embedded `asset.extras.modly` copy carries the same name/project/tags
+ * fields; the sidecar additionally owns creation time and lineage.
+ */
+export interface AssetLibrarySemanticMetadata {
+  name?: string
+  project?: string
+  tags: string[]
+  created?: string
+  derivedFrom?: AssetLibraryDerivedFrom
 }
 
 export interface AssetLibrarySourceLink {
@@ -81,3 +107,27 @@ export type AssetLibraryReadResult =
 export type AssetLibraryOpenResult =
   | { success: true, entry: AssetLibraryEntry }
   | { success: false, error: AssetLibraryError }
+
+export interface AssetLibraryPreviewClip {
+  /** Animation clip name, matched against the manifest and echoed back on request. */
+  clip: string
+  /** Loop duration in seconds, as reported by the manifest. */
+  duration: number
+}
+
+export interface AssetLibraryThumbnailRequest {
+  workspacePath: string
+  /**
+   * When set, request the looping preview WebP for this clip instead of the
+   * static thumbnail. Omit to fetch the static thumbnail (default), which also
+   * carries the `previews` clip list when one exists so the UI can decide
+   * whether hover-to-animate is available at all.
+   */
+  previewClip?: string
+}
+
+// Missing thumbnails are an expected, silent condition (not every asset has
+// a rendered preview), so failure carries no error payload for the UI to show.
+export type AssetLibraryThumbnailResult =
+  | { success: true, dataUrl: string, previews?: AssetLibraryPreviewClip[] }
+  | { success: false }
diff --git a/src/shared/types/electron.d.ts b/src/shared/types/electron.d.ts
index f631f6d5..09c496ab 100644
--- a/src/shared/types/electron.d.ts
+++ b/src/shared/types/electron.d.ts
@@ -7,7 +7,10 @@ import type {
   AssetLibraryOpenResult,
   AssetLibraryReadRequest,
   AssetLibraryReadResult,
+  AssetLibraryThumbnailRequest,
+  AssetLibraryThumbnailResult,
 } from './assetLibrary'
+import type { TextureWatchChoice, TextureWatchUpdate } from './liveTexture'
 
 // ─── Extension types ──────────────────────────────────────────────────────────
 
@@ -47,7 +50,7 @@ export interface ModelExtension {
 export interface ParamSchema {
   id:       string
   label:    string
-  type:     'select' | 'int' | 'float' | 'string' | 'file-select'
+  type:     'select' | 'int' | 'float' | 'string' | 'text' | 'file-select'
   default:  number | string
   options?: { value: number | string; label: string }[]
   min?:     number
@@ -58,6 +61,9 @@ export interface ParamSchema {
   // file-select: dropdown of the files inside the folder held by another param
   dir_from?:   string     // id of the (string) param holding the folder path
   extensions?: string[]   // file extensions to list (e.g. ["json"])
+  // Renders a tall, resizable textarea instead of a single-line input,
+  // regardless of the base type (e.g. a "string" param with a long description).
+  multiline?: boolean
 }
 
 export interface ProcessExtension {
@@ -89,6 +95,9 @@ export interface ProcessInput {
   /** Per-slot texts for multi-text-input nodes (index = target handle slot). */
   texts?:    (string | undefined)[]
   nodeId?:   string
+  /** Absolute path of the existing workspace asset this input was sourced from
+   *  (if any) — threaded through the run so mesh-exporter can record lineage. */
+  sourceAssetPath?: string
 }
 
 export interface ProcessResult {
@@ -136,12 +145,22 @@ export interface Workflow {
   folder?:     string
   /** Pinned in the workflow browser's Bookmarks section */
   bookmarked?: boolean
+  /** Keeps one operator-facing choice authoritative when multiple nodes need
+   *  the same value (for example generation density and fallback decimation). */
+  paramBindings?: WorkflowParamBinding[]
   nodes:       WFNode[]
   edges:       WFEdge[]
   createdAt:   string
   updatedAt:   string
 }
 
+export interface WorkflowParamBinding {
+  sourceNodeId: string
+  sourceParam:  string
+  targetNodeId: string
+  targetParam:  string
+}
+
 declare global {
   interface Window {
     electron: {
@@ -161,6 +180,8 @@ declare global {
       }
       ui: {
         setZoomFactor: (factor: number) => void
+        onZoomStep: (cb: (step: number) => void) => void
+        offZoomStep: () => void
       }
       python: {
         start:     () => Promise<{ success: boolean; port?: number; error?: string }>
@@ -184,6 +205,12 @@ declare global {
         deleteDirectory: (dirPath: string) => Promise<{ success: boolean; error?: string }>
         readScreenshotDataUrl: (filename: string) => Promise<string>
       }
+      texture: {
+        chooseAndWatch: () => Promise<TextureWatchChoice>
+        stopWatching:  () => Promise<void>
+        onChange:      (cb: (update: TextureWatchUpdate) => void) => void
+        offChange:     () => void
+      }
       settings: {
         get: () => Promise<{ modelsDir: string; workspaceDir: string; workflowsDir: string; extensionsDir: string; hfToken?: string }>
         set: (patch: { modelsDir?: string; workspaceDir?: string; workflowsDir?: string; extensionsDir?: string; hfToken?: string }) => Promise<{ modelsDir: string; workspaceDir: string; workflowsDir: string; extensionsDir: string; hfToken?: string }>
@@ -250,6 +277,7 @@ declare global {
           list: () => Promise<AssetLibraryListResult>
           read: (request: AssetLibraryReadRequest) => Promise<AssetLibraryReadResult>
           open: (request: AssetLibraryOpenRequest) => Promise<AssetLibraryOpenResult>
+          thumbnail: (request: AssetLibraryThumbnailRequest) => Promise<AssetLibraryThumbnailResult>
         }
       }
       setup: {
diff --git a/src/shared/types/liveTexture.ts b/src/shared/types/liveTexture.ts
new file mode 100644
index 00000000..94c9f2bb
--- /dev/null
+++ b/src/shared/types/liveTexture.ts
@@ -0,0 +1,18 @@
+export type TextureWatchState = 'reading' | 'ready' | 'error'
+
+export interface TextureWatchUpdate {
+  state: TextureWatchState
+  filePath: string
+  fileName: string
+  revision: number
+  changedAt: number
+  savedAt?: number
+  width?: number
+  height?: number
+  dataUrl?: string
+  message?: string
+}
+
+export type TextureWatchChoice =
+  | { cancelled: true }
+  | { cancelled: false; update: TextureWatchUpdate }
diff --git a/texture-hot-reload-proof/01-before.png b/texture-hot-reload-proof/01-before.png
new file mode 100644
index 00000000..012c63da
Binary files /dev/null and b/texture-hot-reload-proof/01-before.png differ
diff --git a/texture-hot-reload-proof/02-after.png b/texture-hot-reload-proof/02-after.png
new file mode 100644
index 00000000..bdc5ded1
Binary files /dev/null and b/texture-hot-reload-proof/02-after.png differ
diff --git a/texture-hot-reload-proof/03-malformed.png b/texture-hot-reload-proof/03-malformed.png
new file mode 100644
index 00000000..f64602cf
Binary files /dev/null and b/texture-hot-reload-proof/03-malformed.png differ
diff --git a/texture-hot-reload-proof/04-recovered.png b/texture-hot-reload-proof/04-recovered.png
new file mode 100644
index 00000000..39cb047d
Binary files /dev/null and b/texture-hot-reload-proof/04-recovered.png differ
diff --git a/texture-hot-reload-proof/05-wrong-size.png b/texture-hot-reload-proof/05-wrong-size.png
new file mode 100644
index 00000000..cfd93eb3
Binary files /dev/null and b/texture-hot-reload-proof/05-wrong-size.png differ
diff --git a/texture-hot-reload-proof/README.md b/texture-hot-reload-proof/README.md
new file mode 100644
index 00000000..27bcd3fd
--- /dev/null
+++ b/texture-hot-reload-proof/README.md
@@ -0,0 +1,28 @@
+# Texture update proof
+
+The installed Modly app stayed open throughout this proof. A separate test window
+used the same file watcher, texture replacement, and visible status as the 3D
+preview.
+
+## Watched result
+
+- `01-before.png`: watched frame before the save, with a red and yellow 64 x 64
+  checker and `Watching paint.png` visible.
+- `02-after.png`: watched frame after Blender saved a blue and green checker to
+  the same file. The model, camera, and window did not reload.
+- Measured time from the file save to the new texture being applied: **63 ms**.
+- `04-recovered.png`: watched frame after restoring a valid file.
+
+The square edges stayed crisp. The reload continues to use the nearest pixel for
+both close and distant views and does not make softened copies.
+
+## Visible failures
+
+- `03-malformed.png`: the watched file was cut to 20 bytes. The old texture
+  remained visible, while a red `Texture not updated` message explained that the
+  file might still be saving or damaged.
+- `05-wrong-size.png`: Blender saved a valid 32 x 32 image over the watched
+  64 x 64 image. The old texture remained visible, while the message named both
+  sizes and said to save at 64 x 64.
+
+The watcher stayed active after both failures and accepted the next valid save.
diff --git a/texture-hot-reload-proof/index.html b/texture-hot-reload-proof/index.html
new file mode 100644
index 00000000..96ab48f0
--- /dev/null
+++ b/texture-hot-reload-proof/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Texture update proof</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/renderer.tsx"></script>
+  </body>
+</html>
diff --git a/texture-hot-reload-proof/main.ts b/texture-hot-reload-proof/main.ts
new file mode 100644
index 00000000..3208bcf3
--- /dev/null
+++ b/texture-hot-reload-proof/main.ts
@@ -0,0 +1,74 @@
+import { app, BrowserWindow, ipcMain } from 'electron'
+import { writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { TextureWatchService } from '../electron/main/texture-watch-service'
+
+const texturePath = process.env.MODLY_TEXTURE_PROOF_FILE
+const rendererUrl = process.env.MODLY_TEXTURE_PROOF_URL ?? 'http://127.0.0.1:4177'
+if (!texturePath) throw new Error('MODLY_TEXTURE_PROOF_FILE is required')
+
+const service = new TextureWatchService()
+
+app.setName('Texture update proof')
+app.setPath('userData', join(__dirname, 'user-data'))
+
+app.whenReady().then(() => {
+  ipcMain.handle('texture:chooseAndWatch', async (event) => {
+    console.log('[proof] choose requested')
+    const update = await service.start(event.sender.id, texturePath, (next) => {
+      if (!event.sender.isDestroyed()) event.sender.send('texture:changed', next)
+    })
+    console.log(`[proof] initial texture state: ${update.state}`)
+    return { cancelled: false, update }
+  })
+  ipcMain.handle('texture:stopWatching', (event) => service.stop(event.sender.id))
+
+  const win = new BrowserWindow({
+    width: 960,
+    height: 720,
+    show: false,
+    title: 'Texture update proof',
+    backgroundColor: '#18181b',
+    webPreferences: {
+      preload: join(__dirname, '../out/preload/index.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false,
+    },
+  })
+  win.webContents.on('console-message', (_event, ...args: unknown[]) => {
+    const first = args[0]
+    const message = typeof first === 'object' && first && 'message' in first
+      ? String(first.message)
+      : String(args[1] ?? first)
+    console.log(`[proof] ${message}`)
+  })
+  const captureNames: Record<string, string> = {
+    F6: '01-before.png',
+    F7: '02-after.png',
+    F8: '03-malformed.png',
+    F9: '04-recovered.png',
+  }
+  win.webContents.on('before-input-event', (event, input) => {
+    if (input.type === 'keyDown' && input.key === 'F5') {
+      event.preventDefault()
+      void win.webContents.executeJavaScript(
+        "document.querySelector('[data-testid=\"watch-texture-button\"]')?.click()",
+      )
+      return
+    }
+    const name = captureNames[input.key]
+    if (input.type !== 'keyDown' || !name) return
+    event.preventDefault()
+    void win.webContents.capturePage().then(async (image) => {
+      await writeFile(join(__dirname, name), image.toPNG())
+      console.log(`[proof] captured ${name}`)
+    })
+  })
+  win.once('ready-to-show', () => win.show())
+  void win.loadURL(rendererUrl)
+})
+
+app.on('before-quit', () => service.stopAll())
+app.on('window-all-closed', () => app.quit())
diff --git a/texture-hot-reload-proof/paint-in-blender.py b/texture-hot-reload-proof/paint-in-blender.py
new file mode 100644
index 00000000..a8c694fa
--- /dev/null
+++ b/texture-hot-reload-proof/paint-in-blender.py
@@ -0,0 +1,28 @@
+import sys
+
+import bpy
+
+
+def arguments():
+    marker = sys.argv.index("--")
+    values = sys.argv[marker + 1:]
+    return values[0], values[1], int(values[2]) if len(values) > 2 else 64
+
+
+output_path, palette, size = arguments()
+colors = {
+    "before": ((0.95, 0.08, 0.08, 1.0), (1.0, 0.8, 0.08, 1.0)),
+    "after": ((0.02, 0.18, 1.0, 1.0), (0.02, 0.9, 0.65, 1.0)),
+}
+first, second = colors[palette]
+tile = 8
+pixels = []
+for y in range(size):
+    for x in range(size):
+        pixels.extend(first if (x // tile + y // tile) % 2 == 0 else second)
+
+image = bpy.data.images.new("paint", width=size, height=size, alpha=True)
+image.pixels = pixels
+image.filepath_raw = output_path
+image.file_format = "PNG"
+image.save()
diff --git a/texture-hot-reload-proof/paint.png b/texture-hot-reload-proof/paint.png
new file mode 100644
index 00000000..7b73a928
Binary files /dev/null and b/texture-hot-reload-proof/paint.png differ
diff --git a/texture-hot-reload-proof/renderer.tsx b/texture-hot-reload-proof/renderer.tsx
new file mode 100644
index 00000000..1a4fda63
--- /dev/null
+++ b/texture-hot-reload-proof/renderer.tsx
@@ -0,0 +1,68 @@
+import { useEffect, useState } from 'react'
+import { createRoot } from 'react-dom/client'
+import { Canvas, useLoader } from '@react-three/fiber'
+import * as THREE from 'three'
+
+import LiveTexturePanel from '../src/areas/generate/components/LiveTexturePanel'
+import '../src/styles/globals.css'
+import './styles.css'
+
+function ProofModel({ onObject }: { onObject: (object: THREE.Object3D) => void }): JSX.Element {
+  const texture = useLoader(THREE.TextureLoader, '/paint.png')
+  texture.colorSpace = THREE.SRGBColorSpace
+  texture.magFilter = THREE.NearestFilter
+  texture.minFilter = THREE.NearestFilter
+  texture.generateMipmaps = false
+
+  return (
+    <group ref={(value) => { if (value) onObject(value) }} rotation={[0.25, -0.55, 0]}>
+      <mesh>
+        <boxGeometry args={[2.5, 2.5, 2.5]} />
+        <meshStandardMaterial map={texture} roughness={0.78} />
+      </mesh>
+    </group>
+  )
+}
+
+function App(): JSX.Element {
+  const [object, setObject] = useState<THREE.Object3D | null>(null)
+
+  useEffect(() => {
+    const report = (event: Event) => {
+      const detail = (event as CustomEvent).detail as {
+        savedAt?: number
+        detectedAt: number
+        appliedAt: number
+        revision: number
+      }
+      const latency = detail.savedAt ? Math.round(detail.appliedAt - detail.savedAt) : null
+      console.log(JSON.stringify({ event: 'texture-updated', latency, ...detail }))
+    }
+    window.addEventListener('modly:texture-updated', report)
+    return () => window.removeEventListener('modly:texture-updated', report)
+  }, [])
+
+  return (
+    <main
+      className="relative overflow-hidden bg-zinc-900"
+      style={{ width: '100vw', height: '100vh' }}
+    >
+      <div className="absolute left-5 top-5 z-10">
+        <h1 className="text-base font-semibold text-white">Texture update proof</h1>
+        <p className="mt-1 text-xs text-zinc-400">The cube changes when paint.png is saved.</p>
+      </div>
+      <Canvas camera={{ position: [0, 0.4, 6], fov: 42 }} dpr={1}>
+        <color attach="background" args={['#18181b']} />
+        <ambientLight intensity={1.2} />
+        <directionalLight position={[4, 6, 5]} intensity={3} />
+        <ProofModel onObject={setObject} />
+      </Canvas>
+      <LiveTexturePanel object={object} onApplied={() => undefined} />
+      <p className="absolute bottom-5 left-1/2 -translate-x-1/2 text-xs text-zinc-500">
+        Watching a file outside Modly
+      </p>
+    </main>
+  )
+}
+
+createRoot(document.getElementById('root')!).render(<App />)
diff --git a/texture-hot-reload-proof/styles.css b/texture-hot-reload-proof/styles.css
new file mode 100644
index 00000000..bd49912c
--- /dev/null
+++ b/texture-hot-reload-proof/styles.css
@@ -0,0 +1,7 @@
+html,
+body,
+#root {
+  width: 100%;
+  height: 100%;
+  margin: 0;
+}
diff --git a/texture-hot-reload-proof/vite.config.mjs b/texture-hot-reload-proof/vite.config.mjs
new file mode 100644
index 00000000..7d2db650
--- /dev/null
+++ b/texture-hot-reload-proof/vite.config.mjs
@@ -0,0 +1,18 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import { resolve } from 'node:path'
+
+export default defineConfig({
+  root: import.meta.dirname,
+  server: {
+    host: '127.0.0.1',
+    port: 4177,
+    strictPort: true,
+  },
+  resolve: {
+    alias: {
+      '@shared': resolve(import.meta.dirname, '../src/shared'),
+    },
+  },
+  plugins: [react()],
+})
diff --git a/tsconfig.builtins.json b/tsconfig.builtins.json
index 5a7a957a..b1ddacc6 100644
--- a/tsconfig.builtins.json
+++ b/tsconfig.builtins.json
@@ -12,6 +12,7 @@
     "esModuleInterop":   true
   },
   "include": [
+    "src/areas/workflows/nodes/intent-travel/**/*.ts",
     "src/areas/workflows/nodes/mesh-exporter/**/*.ts",
     "src/areas/workflows/nodes/mesh-optimizer/**/*.ts"
   ]