diff --git a/.gitignore b/.gitignore
index d816e79..f658e18 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,3 +34,19 @@ release
 .DS_Store
 
 .npmrc
+.playwright-mcp/page-2026-07-18T20-27-09-682Z.png
+.playwright-mcp/page-2026-07-18T20-27-30-442Z.yml
+.playwright-mcp/page-2026-07-18T20-28-21-488Z.png
+.playwright-mcp/page-2026-07-18T20-28-37-637Z.yml
+.playwright-mcp/page-2026-07-18T20-29-00-648Z.yml
+.playwright-mcp/page-2026-07-18T20-29-06-561Z.png
+.playwright-mcp/page-2026-07-18T20-29-30-963Z.png
+.playwright-mcp/page-2026-07-18T20-30-00-042Z.yml
+.playwright-mcp/page-2026-07-18T20-30-13-245Z.png
+.playwright-mcp/page-2026-07-18T20-33-32-651Z.png
+.playwright-mcp/page-2026-07-18T20-35-28-430Z.png
+.playwright-mcp/page-2026-07-18T21-05-49-608Z.yml
+.playwright-mcp/page-2026-07-18T21-06-19-346Z.yml
+.playwright-mcp/page-2026-07-18T21-06-51-089Z.yml
+.playwright-mcp/page-2026-07-18T21-07-01-786Z.yml
+.playwright-mcp/page-2026-07-18T21-07-06-202Z.yml
diff --git a/.mcp.json b/.mcp.json
new file mode 100644
index 0000000..fcbfcf3
--- /dev/null
+++ b/.mcp.json
@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "playwright": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@playwright/mcp@latest",
+        "--cdp-endpoint",
+        "http://127.0.0.1:9222"
+      ]
+    }
+  }
+}
diff --git a/package-lock.json b/package-lock.json
index c9a8bda..d57e268 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -21,7 +21,7 @@
         "ffprobe-static": "^3.1.0",
         "fluent-ffmpeg": "^2.1.3",
         "markdown-it": "^14.1.1",
-        "pilotui": "^1.28.1",
+        "pilotui": "^1.29.1",
         "pinia": "^3.0.4",
         "uuid": "^13.0.0",
         "vue": "^3.4.21",
@@ -1026,12 +1026,12 @@
       }
     },
     "node_modules/@storybook/builder-vite": {
-      "version": "8.6.15",
-      "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-8.6.15.tgz",
-      "integrity": "sha512-9Y05/ndZE6/eI7ZIUCD/QtH2htRIUs9j1gxE6oW0zRo9TJO1iqxfLNwgzd59KEkId7gdZxPei0l+LGTUGXYKRg==",
+      "version": "8.6.18",
+      "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-8.6.18.tgz",
+      "integrity": "sha512-XLqnOv4C36jlTd4uC8xpWBxv+7GV4/05zWJ0wAcU4qflorropUTirt4UQPGkwIzi+BVAhs9pJj+m4k0IWJtpHg==",
       "license": "MIT",
       "dependencies": {
-        "@storybook/csf-plugin": "8.6.15",
+        "@storybook/csf-plugin": "8.6.18",
         "browser-assert": "^1.2.1",
         "ts-dedent": "^2.0.0"
       },
@@ -1040,7 +1040,7 @@
         "url": "https://opencollective.com/storybook"
       },
       "peerDependencies": {
-        "storybook": "^8.6.15",
+        "storybook": "^8.6.18",
         "vite": "^4.0.0 || ^5.0.0 || ^6.0.0"
       }
     },
@@ -1077,9 +1077,9 @@
       }
     },
     "node_modules/@storybook/core/node_modules/semver": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "version": "7.8.5",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
       "license": "ISC",
       "peer": true,
       "bin": {
@@ -1090,9 +1090,9 @@
       }
     },
     "node_modules/@storybook/csf-plugin": {
-      "version": "8.6.15",
-      "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-8.6.15.tgz",
-      "integrity": "sha512-ZLz/mtOoE1Jj2lE4pK3U7MmYrv5+lot3mGtwxGb832tcABMc97j9O+reCVxZYc7DeFbBuuEdMT9rBL/O3kXYmw==",
+      "version": "8.6.18",
+      "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-8.6.18.tgz",
+      "integrity": "sha512-x1ioz/L0CwaelCkHci3P31YtvwayN3FBftvwQOPbvRh9qeb4Cpz5IdVDmyvSxxYwXN66uAORNoqgjTi7B4/y5Q==",
       "license": "MIT",
       "dependencies": {
         "unplugin": "^1.3.1"
@@ -1102,7 +1102,7 @@
         "url": "https://opencollective.com/storybook"
       },
       "peerDependencies": {
-        "storybook": "^8.6.15"
+        "storybook": "^8.6.18"
       }
     },
     "node_modules/@storybook/theming": {
@@ -1158,9 +1158,9 @@
       }
     },
     "node_modules/@tanstack/virtual-core": {
-      "version": "3.13.18",
-      "resolved": "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.13.18.tgz",
-      "integrity": "sha512-Mx86Hqu1k39icq2Zusq+Ey2J6dDWTjDvEv43PJtRCoEYTLyfaPnxIQ6iy7YAOK0NV/qOEmZQ/uCufrppZxTgcg==",
+      "version": "3.17.4",
+      "resolved": "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.17.4.tgz",
+      "integrity": "sha512-nGm5KteqxasUdThLc2izl6dHUqLv0LQj7Nuyo5gYalTPf/U8a9ermvsl7reT+6ioBW1l8WfpP/mcU338nLXpqw==",
       "license": "MIT",
       "funding": {
         "type": "github",
@@ -1168,12 +1168,12 @@
       }
     },
     "node_modules/@tanstack/vue-virtual": {
-      "version": "3.13.18",
-      "resolved": "https://registry.npmjs.org/@tanstack/vue-virtual/-/vue-virtual-3.13.18.tgz",
-      "integrity": "sha512-6pT8HdHtTU5Z+t906cGdCroUNA5wHjFXsNss9gwk7QAr1VNZtz9IQCs2Nhx0gABK48c+OocHl2As+TMg8+Hy4A==",
+      "version": "3.13.32",
+      "resolved": "https://registry.npmjs.org/@tanstack/vue-virtual/-/vue-virtual-3.13.32.tgz",
+      "integrity": "sha512-E8OCutx7QnwZdvpJijz0Q2PHsYDWBWjnGr3TvgWiqxTU35jB1kVhtkd93scRV7tTFuId2tg3x2iFiw+IE4evjQ==",
       "license": "MIT",
       "dependencies": {
-        "@tanstack/virtual-core": "3.13.18"
+        "@tanstack/virtual-core": "3.17.4"
       },
       "funding": {
         "type": "github",
@@ -1193,15 +1193,6 @@
         "node": ">= 10"
       }
     },
-    "node_modules/@trysound/sax": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz",
-      "integrity": "sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==",
-      "license": "ISC",
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
     "node_modules/@types/cacheable-request": {
       "version": "6.0.3",
       "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz",
@@ -1753,9 +1744,9 @@
       "license": "MIT"
     },
     "node_modules/acorn": {
-      "version": "8.15.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
-      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+      "version": "8.17.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.17.0.tgz",
+      "integrity": "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==",
       "license": "MIT",
       "bin": {
         "acorn": "bin/acorn"
@@ -2491,15 +2482,15 @@
       }
     },
     "node_modules/call-bind": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
-      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.9.tgz",
+      "integrity": "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==",
       "license": "MIT",
       "peer": true,
       "dependencies": {
-        "call-bind-apply-helpers": "^1.0.0",
-        "es-define-property": "^1.0.0",
-        "get-intrinsic": "^1.2.4",
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "get-intrinsic": "^1.3.0",
         "set-function-length": "^1.2.2"
       },
       "engines": {
@@ -5256,9 +5247,9 @@
       "license": "MIT"
     },
     "node_modules/lodash-es": {
-      "version": "4.17.23",
-      "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.23.tgz",
-      "integrity": "sha512-kVI48u3PZr38HdYz98UmfPnXl2DXrpdctLrFLCd3kOx1xUkOmpFPx7gCWWM5MPkL/fD8zb+Ph0QzjGFs4+hHWg==",
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.18.1.tgz",
+      "integrity": "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==",
       "license": "MIT"
     },
     "node_modules/lodash.clonedeep": {
@@ -5295,6 +5286,7 @@
       "version": "4.5.0",
       "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
       "integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==",
+      "deprecated": "This package is deprecated. Use require('node:util').isDeepStrictEqual instead.",
       "license": "MIT"
     },
     "node_modules/lodash.isplainobject": {
@@ -5888,9 +5880,10 @@
       }
     },
     "node_modules/pilotui": {
-      "version": "1.28.1",
-      "resolved": "https://registry.npmjs.org/pilotui/-/pilotui-1.28.1.tgz",
-      "integrity": "sha512-S9MJt00HEBUUBk775bOSTWkkkVjjce7lFsvOC+q0ovqfAo3/x0vGHkSUyzNrj2nelAyoZQQuCYYsA1Pn20Ylow==",
+      "version": "1.29.1",
+      "resolved": "https://registry.npmjs.org/pilotui/-/pilotui-1.29.1.tgz",
+      "integrity": "sha512-DwAv34kB1K+17OR/bsJly+yE/I19mHkbQstbaThbmiu4vA/o2wwbj6dPQFbpgwkoJEFFIY7ojzCt9cy4evcfpw==",
+      "license": "MIT",
       "dependencies": {
         "@headlessui/vue": "^1.7.23",
         "@storybook/builder-vite": "^8.4.5",
@@ -6788,9 +6781,9 @@
       }
     },
     "node_modules/recast": {
-      "version": "0.23.11",
-      "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz",
-      "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==",
+      "version": "0.23.12",
+      "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.12.tgz",
+      "integrity": "sha512-dEWRjcINDu/F4l2dYx57ugBtD7HV9KXESyxhzw/MqWLeglJrsjJKqACPyUPg+6AF8mIgm+Zi0dZ3ACoIg+QtpA==",
       "license": "MIT",
       "peer": true,
       "dependencies": {
@@ -7037,10 +7030,9 @@
       }
     },
     "node_modules/sax": {
-      "version": "1.4.4",
-      "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.4.tgz",
-      "integrity": "sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw==",
-      "dev": true,
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",
+      "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
       "license": "BlueOak-1.0.0",
       "engines": {
         "node": ">=11.0.0"
@@ -7236,6 +7228,7 @@
       "version": "0.1.8",
       "resolved": "https://registry.npmjs.org/stable/-/stable-0.1.8.tgz",
       "integrity": "sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==",
+      "deprecated": "Modern JS already guarantees Array#sort() is a stable sort, so this library is deprecated. See the compatibility table on MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#browser_compatibility",
       "license": "MIT"
     },
     "node_modules/stat-mode": {
@@ -7427,17 +7420,17 @@
       }
     },
     "node_modules/svgo": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/svgo/-/svgo-2.8.0.tgz",
-      "integrity": "sha512-+N/Q9kV1+F+UeWYoSiULYo4xYSDQlTgb+ayMobAXPwMnLvop7oxKMo9OzIrX5x3eS4L4f2UHhc9axXwY8DpChg==",
+      "version": "2.8.3",
+      "resolved": "https://registry.npmjs.org/svgo/-/svgo-2.8.3.tgz",
+      "integrity": "sha512-5EZD0pafXX6PphdwOGCiVLDSaV1xyuQao2blHajHLsPxr07q4mmEjdtXEWgG07ae2mIz8Ex2CDXNCTiXhy3Khw==",
       "license": "MIT",
       "dependencies": {
-        "@trysound/sax": "0.2.0",
         "commander": "^7.2.0",
         "css-select": "^4.1.3",
         "css-tree": "^1.1.3",
         "csso": "^4.2.0",
         "picocolors": "^1.0.0",
+        "sax": "^1.5.0",
         "stable": "^0.1.8"
       },
       "bin": {
@@ -7457,9 +7450,9 @@
       }
     },
     "node_modules/sweetalert2": {
-      "version": "11.26.18",
-      "resolved": "https://registry.npmjs.org/sweetalert2/-/sweetalert2-11.26.18.tgz",
-      "integrity": "sha512-3O5feBqV+hTIOwCRKGuZGHosjiuBAKP/vpBl6vKFZeVYfCUGdXqXuuidn6YXHan3f6e62UdmnjwJBt8UtDVBhg==",
+      "version": "11.26.25",
+      "resolved": "https://registry.npmjs.org/sweetalert2/-/sweetalert2-11.26.25.tgz",
+      "integrity": "sha512-+hunCOJdJ6FLj04T9YSLvvZXRjsvIkTeTKP2e4VF8CaBias961BTnWiSFAy7F/CM5eq3QK2Rraoc5Gzftslvkg==",
       "license": "MIT",
       "funding": {
         "type": "individual",
@@ -7688,9 +7681,9 @@
       }
     },
     "node_modules/ts-dedent": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.2.0.tgz",
-      "integrity": "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==",
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.3.0.tgz",
+      "integrity": "sha512-JfJeIHke7y2egdGGgRAvpCwYFUsHlM2gPcrVOxFkznt/4uzQ7HFmvE63iFHVLBJNDuyDOQgijDK/tXH/f6Msjg==",
       "license": "MIT",
       "engines": {
         "node": ">=6.10"
@@ -8124,14 +8117,14 @@
       }
     },
     "node_modules/which-typed-array": {
-      "version": "1.1.20",
-      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.20.tgz",
-      "integrity": "sha512-LYfpUkmqwl0h9A2HL09Mms427Q1RZWuOHsukfVcKRq9q95iQxdw0ix1JQrqbcDR9PH1QDwf5Qo8OZb5lksZ8Xg==",
+      "version": "1.1.22",
+      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.22.tgz",
+      "integrity": "sha512-fvO4ExWMFsqyhG3AiPAObMuY1lxaqgYcxbc49CNdWDDECOJNgQyvsOWVwbZc+qf3rzRtxojBK+CMEv0Ld5CYpw==",
       "license": "MIT",
       "peer": true,
       "dependencies": {
         "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
+        "call-bind": "^1.0.9",
         "call-bound": "^1.0.4",
         "for-each": "^0.3.5",
         "get-proto": "^1.0.1",
diff --git a/package.json b/package.json
index 7ddd94f..9f5468d 100644
--- a/package.json
+++ b/package.json
@@ -13,6 +13,7 @@
     "typecheck:web": "vue-tsc -p tsconfig.web.json --noEmit",
     "typecheck": "npm run typecheck:node && npm run typecheck:web || true",
     "start": "electron-vite preview",
+    "start:debug": "electron-vite build && electron out/main/index.js --remote-debugging-port=9222",
     "dev": "electron-vite dev",
     "build": "electron-vite build",
     "postinstall": "electron-builder install-app-deps",
@@ -33,7 +34,7 @@
     "ffprobe-static": "^3.1.0",
     "fluent-ffmpeg": "^2.1.3",
     "markdown-it": "^14.1.1",
-    "pilotui": "^1.28.1",
+    "pilotui": "^1.29.1",
     "pinia": "^3.0.4",
     "uuid": "^13.0.0",
     "vue": "^3.4.21",
diff --git a/src/main/constants/gemini.ts b/src/main/constants/gemini.ts
index 97f33af..b2754e1 100644
--- a/src/main/constants/gemini.ts
+++ b/src/main/constants/gemini.ts
@@ -96,6 +96,7 @@ export const DEFAULT_MODEL_SETTINGS: ModelSettings = {
 		'image-extraction': GEMINI_MODEL_2_5_FLASH_LITE,
 		'image-intent': GEMINI_MODEL_2_5_FLASH,
 		'image-generation': GEMINI_MODEL_3_1_FLASH_IMAGE_PREVIEW,
-		'image-upscale': GEMINI_MODEL_3_1_FLASH_IMAGE_PREVIEW
+		'image-upscale': GEMINI_MODEL_3_1_FLASH_IMAGE_PREVIEW,
+		'editor-edit': GEMINI_MODEL_3_FLASH_PREVIEW
 	}
 }
diff --git a/src/main/constants/paths.ts b/src/main/constants/paths.ts
index 0122318..d95b32c 100644
--- a/src/main/constants/paths.ts
+++ b/src/main/constants/paths.ts
@@ -6,5 +6,20 @@ export const THREAD_DIRS = {
 	GENERATED_VIDEOS: 'generated-videos',
 	AUDIO: 'audio',
 	VIDEO: 'video',
-	TRANSCRIPTS: 'transcripts'
+	TRANSCRIPTS: 'transcripts',
+	// Timeline editor: per-asset artifact root (tempDir/media/<assetId>/...)
+	MEDIA: 'media',
+	// Timeline editor: export workdirs + final renders (tempDir/exports/...)
+	EXPORTS: 'exports'
+} as const
+
+// Subdirectories inside tempDir/media/<assetId>/ for the timeline editor.
+// FRAMES/ANALYSIS/AUDIO intentionally reuse THREAD_DIRS names so pipeline
+// phases run per-asset when given an asset-scoped tempDir.
+export const ASSET_DIRS = {
+	SOURCE: 'source',
+	PROXY: 'proxy',
+	ANALYSIS: THREAD_DIRS.ANALYSIS,
+	FRAMES: THREAD_DIRS.FRAMES,
+	AUDIO: THREAD_DIRS.AUDIO
 } as const
diff --git a/src/main/constants/personas.ts b/src/main/constants/personas.ts
new file mode 100644
index 0000000..76fcdb6
--- /dev/null
+++ b/src/main/constants/personas.ts
@@ -0,0 +1,196 @@
+import type { EditorPersona } from '@shared/types'
+
+/**
+ * Built-in editor personas (video-editor-prd.md §5.8).
+ * NEVER persisted to settings.json — merged with the user's saved personas at
+ * read time, so prompt improvements ship with app updates. Long-form personas
+ * carry `targetDurationSec: null` = length-preserving editorial mode; the
+ * summarize group targets a shorter duration.
+ */
+
+export const DEFAULT_PERSONA_ID = 'podcast-editor'
+
+export const BUILTIN_PERSONAS: EditorPersona[] = [
+	// ===== Long-form (length-preserving editorial) =====
+	{
+		id: 'podcast-editor',
+		name: 'Podcast Editor',
+		icon: '🎙️',
+		description: 'Keeps the full conversation; removes dead air and false starts; tightens rambling stretches.',
+		builtin: true,
+		mode: 'longform',
+		tone: 'neutral',
+		defaults: { targetDurationSec: null, pacing: 'relaxed' },
+		featureSets: [],
+		systemPrompt: [
+			'You are a seasoned podcast editor. Your job is to keep the FULL conversation',
+			'intact while making it tighter and more listenable.',
+			'- Preserve every distinct point, story, and speaker turn.',
+			'- Remove dead air, long silences, false starts, and duplicated takes.',
+			'- Where a stretch rambles but its content matters, prefer a gentle speed-up',
+			'  (retime via the speed field, up to about 1.3x) over deletion.',
+			'- Keep chronological order unless the user explicitly asks to reorder.',
+			'- Never cut for length alone: the goal is a cleaner version of the whole',
+			'  episode, not a shorter one.'
+		].join('\n')
+	},
+	{
+		id: 'longform-polish',
+		name: 'Long-Form Polisher',
+		icon: '🎬',
+		description: 'For vlogs, webinars, and streams: removes setup fumbles and dead time, smooths pacing.',
+		builtin: true,
+		mode: 'longform',
+		tone: 'warm',
+		defaults: { targetDurationSec: null, pacing: 'balanced' },
+		featureSets: [],
+		systemPrompt: [
+			'You are polishing long-form footage (vlogs, webinars, streams, talks).',
+			'- Remove setup fumbles, technical interruptions, and stretches where',
+			'  nothing substantive happens.',
+			'- Keep the whole narrative and all substantive content.',
+			'- Smooth the pacing: trim slow intros, tighten transitions between topics.',
+			'- Reorder segments only when it clearly improves flow, and explain why in',
+			'  your rationale when you do.'
+		].join('\n')
+	},
+	{
+		id: 'silence-cleaner',
+		name: 'Silence & Filler Cleaner',
+		icon: '🧹',
+		description: 'Aggressively removes silence, dead air, and empty gaps; keeps all substantive content.',
+		builtin: true,
+		mode: 'longform',
+		tone: 'neutral',
+		defaults: { targetDurationSec: null, pacing: 'tight' },
+		featureSets: [],
+		systemPrompt: [
+			'You specialize in cleaning silence and dead air out of recordings.',
+			'- Propose removing scenes whose descriptions indicate silence, empty',
+			'  pauses, dead air, filler, or no visible/audible activity, and scenes',
+			'  that are extremely short with no described content.',
+			'- Leave every scene with spoken or substantive content fully intact.',
+			'- Do not shorten meaningful segments; your only lever is removing the',
+			'  empty material between them.'
+		].join('\n')
+	},
+	{
+		id: 'chapter-organizer',
+		name: 'Chapter Organizer',
+		icon: '🗂️',
+		description: 'Keeps full length; segments the piece into labeled chapters at topic boundaries.',
+		builtin: true,
+		mode: 'longform',
+		tone: 'authoritative',
+		defaults: { targetDurationSec: null, pacing: 'relaxed' },
+		featureSets: [],
+		systemPrompt: [
+			'You organize long recordings into chapters.',
+			'- Keep the full runtime; do not remove or retime content unless asked.',
+			'- Identify logical topic boundaries from the scene descriptions and',
+			'  propose markers (addMarkers) at each boundary with a short, clear label.',
+			'- Prefer 5-12 chapters for a typical long recording; merge minor topic',
+			'  shifts into their parent chapter.',
+			'- Reorder segments only if the user explicitly asks.'
+		].join('\n')
+	},
+	{
+		id: 'study-notes',
+		name: 'Lecture Study-Notes',
+		icon: '🎓',
+		description: 'Retains every scene with distinct instructional content; drops only silence and repetition.',
+		builtin: true,
+		mode: 'longform',
+		tone: 'authoritative',
+		defaults: { targetDurationSec: null, pacing: 'relaxed' },
+		featureSets: [],
+		systemPrompt: [
+			'You are preparing lecture footage for studying.',
+			'- Retain every scene with distinct instructional content: explanations,',
+			'  examples, derivations, demonstrations, and summaries.',
+			'- Drop only silence, repetition, administrative asides, and off-topic',
+			'  tangents.',
+			'- Prioritize completeness over brevity and always preserve chronological',
+			'  order.'
+		].join('\n')
+	},
+
+	// ===== Summarize (target a shorter duration) =====
+	{
+		id: 'concise-summarizer',
+		name: 'Concise Summarizer',
+		icon: '✂️',
+		description: 'Cuts to the essential information; drops redundancy and dead air.',
+		builtin: true,
+		mode: 'summarize',
+		tone: 'neutral',
+		defaults: { targetDurationSec: 60, pacing: 'tight' },
+		featureSets: [],
+		systemPrompt: [
+			'You produce concise summaries of longer footage.',
+			'- Keep only the scenes that advance the core message.',
+			'- Drop redundancy, dead air, and anything tangential.',
+			'- Prefer the shortest coherent edit that still tells the whole story.',
+			'- The result must stand alone: someone who never saw the original should',
+			'  understand it.'
+		].join('\n')
+	},
+	{
+		id: 'highlight-reel',
+		name: 'Highlight Reel',
+		icon: '⚡',
+		description: 'Selects the most visually striking, high-energy scenes with strong opening and closing beats.',
+		builtin: true,
+		mode: 'summarize',
+		tone: 'energetic',
+		defaults: { targetDurationSec: 30, pacing: 'tight' },
+		featureSets: [],
+		systemPrompt: [
+			'You cut high-energy highlight reels.',
+			'- Select the most visually striking scenes: peaks, reactions, motion,',
+			'  and moments of impact, using the scene descriptions as your guide.',
+			'- Favor fast pacing with short clips.',
+			'- Open on a strong hook and end on a memorable closing beat.'
+		].join('\n')
+	},
+	{
+		id: 'storyteller',
+		name: 'Storyteller',
+		icon: '📖',
+		description: 'Assembles a narrative arc — setup, development, payoff — preserving emotional throughline.',
+		builtin: true,
+		mode: 'summarize',
+		tone: 'warm',
+		defaults: { targetDurationSec: 180, pacing: 'balanced' },
+		featureSets: [],
+		systemPrompt: [
+			'You are a narrative editor building a story from footage.',
+			'- Assemble a clear arc: setup, development, payoff.',
+			'- Preserve context and the emotional throughline; keep transitions',
+			'  between selected scenes logical.',
+			'- Prefer scenes that carry narrative weight over merely pretty ones.'
+		].join('\n')
+	},
+	{
+		id: 'social-shorts',
+		name: 'Social / Vertical Shorts',
+		icon: '📱',
+		description: 'Vertical-friendly short: hook in the first seconds, one clear idea, rapid cuts.',
+		builtin: true,
+		mode: 'summarize',
+		tone: 'playful',
+		defaults: { targetDurationSec: 45, aspectRatio: '9:16', pacing: 'tight' },
+		featureSets: [],
+		systemPrompt: [
+			'You cut short-form vertical video for social feeds.',
+			'- Hook the viewer within the first 3 seconds.',
+			'- One clear idea per short; drop everything else.',
+			'- Rapid cuts, no dead time, and end on a strong beat that invites a',
+			'  rewatch.'
+		].join('\n')
+	}
+]
+
+export function findBuiltinPersona(id: string): EditorPersona | undefined {
+	return BUILTIN_PERSONAS.find((p) => p.id === id)
+}
diff --git a/src/main/editor/assets.ts b/src/main/editor/assets.ts
new file mode 100644
index 0000000..50db4e2
--- /dev/null
+++ b/src/main/editor/assets.ts
@@ -0,0 +1,407 @@
+import fs from 'fs'
+import path from 'path'
+import { v4 as uuidv4 } from 'uuid'
+import type { Clip, MediaAsset, Thread } from '@shared/types'
+import { threadManager } from '../threads'
+import { getVideoMetadata, getAudioMetadata, sanitizeFilename } from '../ffmpeg'
+import { ASSET_DIRS, THREAD_DIRS } from '../constants/paths'
+import { abortAssetPreprocessing } from './preprocess'
+
+const AUDIO_EXTENSIONS = new Set([
+	'.mp3', '.wav', '.m4a', '.aac', '.flac', '.ogg', '.oga', '.opus', '.wma'
+])
+
+/** Classify an imported source as audio or video by file extension. */
+export function detectMediaKind(filePath: string): 'audio' | 'video' {
+	return AUDIO_EXTENSIONS.has(path.extname(filePath).toLowerCase()) ? 'audio' : 'video'
+}
+
+/**
+ * Probes a source and returns its real kind + metadata based on which streams
+ * exist. `hint` (from the extension) only decides which probe runs first so the
+ * common case costs one ffprobe; both are tried before giving up.
+ */
+async function probeMediaKind(
+	filePath: string,
+	hint: 'audio' | 'video'
+): Promise<{ kind: 'audio' | 'video'; metadata: MediaAsset['metadata'] } | null> {
+	const tryVideo = async () => ({ kind: 'video' as const, metadata: await getVideoMetadata(filePath) })
+	const tryAudio = async () => ({ kind: 'audio' as const, metadata: await getAudioMetadata(filePath) })
+	const [first, second] = hint === 'audio' ? [tryAudio, tryVideo] : [tryVideo, tryAudio]
+	try {
+		return await first()
+	} catch {
+		try {
+			return await second()
+		} catch (error) {
+			console.error(`[editor] Failed to probe media ${filePath}:`, error)
+			return null
+		}
+	}
+}
+
+/**
+ * Media-asset CRUD for the timeline editor.
+ * Every artifact of an asset lives under tempDir/media/<assetId>/ so
+ * concurrent imports can never collide and removal is one rm -rf.
+ * All document writes go through threadManager.updateThreadWith (queued
+ * mutators) so parallel per-asset updates cannot clobber each other.
+ */
+
+export function getAssetDir(thread: Thread, assetId: string): string {
+	return path.join(thread.tempDir, THREAD_DIRS.MEDIA, assetId)
+}
+
+function ensureDir(dir: string) {
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+}
+
+/**
+ * Imports a source file as a MediaAsset: copies (or moves) it into the
+ * asset's source/ dir, probes metadata, and persists the asset record.
+ * A failed probe persists an error-state asset rather than throwing —
+ * the UI shows it with a retry/remove affordance.
+ */
+export async function createMediaAsset(
+	threadId: string,
+	options: { sourcePath: string; name?: string; move?: boolean; assetId?: string; referenceInPlace?: boolean }
+): Promise<MediaAsset | null> {
+	const thread = threadManager.getThread(threadId)
+	if (!thread || thread.type !== 'editor' || !thread.editor) return null
+
+	if (!fs.existsSync(options.sourcePath) || fs.statSync(options.sourcePath).isDirectory()) {
+		throw new Error(`Invalid media source: "${options.sourcePath}" is not a file.`)
+	}
+
+	const assetId = options.assetId || uuidv4()
+	const assetDir = getAssetDir(thread, assetId)
+
+	const rawName = options.name || path.basename(options.sourcePath)
+	const fileName = sanitizeFilename(rawName)
+
+	// Reference the user's file where it lives instead of copying it in.
+	// Copying a large local source (10–15 GB) with fs.copyFileSync blocks the
+	// main process and freezes the whole UI (including the file dialog). The
+	// editor only needs the path: proxy/thumbnails/export read originalPath
+	// directly, media:// serves any absolute path, removeAsset only clears the
+	// asset dir, and path-repair leaves out-of-tempDir paths untouched. URL
+	// imports still live under the asset dir (they download straight into it).
+	let originalPath: string
+	if (options.referenceInPlace) {
+		originalPath = options.sourcePath
+	} else {
+		const sourceDir = path.join(assetDir, ASSET_DIRS.SOURCE)
+		ensureDir(sourceDir)
+		originalPath = path.join(sourceDir, fileName)
+		if (path.resolve(options.sourcePath) !== path.resolve(originalPath)) {
+			if (options.move) {
+				fs.renameSync(options.sourcePath, originalPath)
+			} else {
+				fs.copyFileSync(options.sourcePath, originalPath)
+			}
+		}
+	}
+
+	const asset: MediaAsset = {
+		id: assetId,
+		kind: 'video',
+		name: rawName,
+		originalPath,
+		preprocessing: {},
+		preprocessState: 'pending',
+		clips: [],
+		createdAt: Date.now()
+	}
+
+	// Kind is decided by what streams actually exist, not the extension —
+	// container formats (.webm/.mkv/.m4a) can be audio-only. The extension only
+	// picks which probe to try first so the common case is a single ffprobe.
+	const probed = await probeMediaKind(originalPath, detectMediaKind(originalPath))
+	if (probed) {
+		asset.kind = probed.kind
+		asset.metadata = probed.metadata
+	} else {
+		asset.preprocessState = 'error'
+		asset.preprocessError = 'Could not read media metadata (corrupt or unsupported file).'
+	}
+
+	await threadManager.updateThreadWith(threadId, (t) => {
+		if (!t.editor) return null
+		const patch: Partial<Thread> = { editor: { ...t.editor, media: [...t.editor.media, asset] } }
+		// Auto-name the project after the first imported media while the title
+		// is still the default — mirrors how chat threads name from the video.
+		if (!t.title || t.title === 'Untitled Project') {
+			const derived = deriveProjectTitle(rawName)
+			if (derived) patch.title = derived
+		}
+		return patch
+	})
+
+	return asset
+}
+
+/** Filename → a clean project title: drop the extension, tidy separators. */
+function deriveProjectTitle(fileName: string): string {
+	const base = fileName.replace(/\.[^./\\]+$/, '') // strip a trailing extension
+	return base.replace(/[_]+/g, ' ').trim().slice(0, 120)
+}
+
+/** Merge a partial patch into one asset record (queued, safe under concurrency). */
+export function patchAsset(
+	threadId: string,
+	assetId: string,
+	patch: Partial<MediaAsset> | ((asset: MediaAsset) => Partial<MediaAsset>)
+): Promise<Thread | null> {
+	return threadManager.updateThreadWith(threadId, (thread) => {
+		if (!thread.editor) return null
+		const index = thread.editor.media.findIndex((a) => a.id === assetId)
+		if (index === -1) return null
+
+		const current = thread.editor.media[index]
+		const resolved = typeof patch === 'function' ? patch(current) : patch
+		const media = [...thread.editor.media]
+		media[index] = { ...current, ...resolved }
+		return { editor: { ...thread.editor, media } }
+	})
+}
+
+/** Merge a preprocessing patch into one asset (mirrors PipelineContext.savePreprocessing). */
+export function patchAssetPreprocessing(
+	threadId: string,
+	assetId: string,
+	patch: Partial<Thread['preprocessing']>
+): Promise<Thread | null> {
+	return patchAsset(threadId, assetId, (asset) => ({
+		preprocessing: { ...(asset.preprocessing || {}), ...patch }
+	}))
+}
+
+// ===== Scene-piece corrections (PRD §5.2 merge / split further) =====
+// Clips are main-owned; these run through patchAsset's queued mutator and
+// return the updated asset so the renderer can patch locally without waiting
+// for the thread-updated echo.
+
+const CLIP_ADJACENCY_EPSILON = 0.1 // seconds — detected scenes abut exactly
+const MIN_SPLIT_PIECE_SEC = 0.2
+
+function reindexClips(clips: Clip[]): Clip[] {
+	return clips.map((c, i) => ({ ...c, index: i + 1 }))
+}
+
+function getUpdatedAsset(threadId: string, assetId: string): MediaAsset | null {
+	return threadManager.getThread(threadId)?.editor?.media.find((a) => a.id === assetId) || null
+}
+
+/** Validate a merge selection; throws a user-facing error on rejection. */
+function validateMergeTargets(asset: MediaAsset, clipIds: string[]): Clip[] {
+	const targets = asset.clips
+		.filter((c) => clipIds.includes(c.id))
+		.sort((a, b) => a.in - b.in)
+	if (targets.length < 2) throw new Error('Selected pieces no longer exist.')
+
+	for (let i = 1; i < targets.length; i++) {
+		if (Math.abs(targets[i].in - targets[i - 1].out) > CLIP_ADJACENCY_EPSILON) {
+			throw new Error('Only adjacent pieces can be merged.')
+		}
+	}
+	return targets
+}
+
+/**
+ * Merge a run of ADJACENT clips (by source time) into one piece spanning
+ * their union. Non-adjacent selections are rejected — merging across a hole
+ * would silently swallow unselected content.
+ *
+ * Validation runs BEFORE the queued mutator (updateThreadWith swallows mutator
+ * throws), so rejections propagate to the renderer; the mutator re-validates
+ * and skips silently if the asset changed mid-flight.
+ */
+export async function mergeClips(
+	threadId: string,
+	assetId: string,
+	clipIds: string[]
+): Promise<MediaAsset | null> {
+	if (clipIds.length < 2) throw new Error('Select at least two pieces to merge.')
+	const current = getUpdatedAsset(threadId, assetId)
+	if (!current) throw new Error('Asset not found.')
+	validateMergeTargets(current, clipIds)
+
+	await patchAsset(threadId, assetId, (asset) => {
+		let targets: Clip[]
+		try {
+			targets = validateMergeTargets(asset, clipIds)
+		} catch {
+			return {} // asset changed mid-flight — skip, don't corrupt
+		}
+
+		const first = targets[0]
+		const last = targets[targets.length - 1]
+		const merged: Clip = {
+			...first,
+			out: last.out,
+			duration: last.out - first.in,
+			visual: targets.map((t) => t.visual).filter(Boolean).join(' ') || undefined,
+			text: targets.map((t) => t.text).filter(Boolean).join(' ') || undefined,
+			selected: true,
+			masterSegmentIndex: undefined // spans multiple master scenes
+		}
+
+		const remainingIds = new Set(clipIds.filter((id) => id !== first.id))
+		const clips = asset.clips
+			.map((c) => (c.id === first.id ? merged : c))
+			.filter((c) => !remainingIds.has(c.id))
+		return { clips: reindexClips(clips) }
+	})
+
+	return getUpdatedAsset(threadId, assetId)
+}
+
+/**
+ * Split one clip into two pieces at `atSec` (source seconds; defaults to the
+ * midpoint). Both halves share the source thumbnail; the left half keeps the
+ * original id so selection/inspector focus degrades gracefully.
+ */
+export async function splitClip(
+	threadId: string,
+	assetId: string,
+	clipId: string,
+	atSec?: number
+): Promise<MediaAsset | null> {
+	// Pre-validate outside the queued mutator (see mergeClips).
+	const current = getUpdatedAsset(threadId, assetId)
+	const candidate = current?.clips.find((c) => c.id === clipId)
+	if (!candidate) throw new Error('Piece no longer exists.')
+	const cutAt = atSec ?? candidate.in + candidate.duration / 2
+	if (cutAt - candidate.in < MIN_SPLIT_PIECE_SEC || candidate.out - cutAt < MIN_SPLIT_PIECE_SEC) {
+		throw new Error('Piece is too short to split.')
+	}
+
+	await patchAsset(threadId, assetId, (asset) => {
+		const target = asset.clips.find((c) => c.id === clipId)
+		if (!target) return {} // asset changed mid-flight — skip
+
+		const at = atSec ?? target.in + target.duration / 2
+		if (at - target.in < MIN_SPLIT_PIECE_SEC || target.out - at < MIN_SPLIT_PIECE_SEC) {
+			return {}
+		}
+
+		const left: Clip = {
+			...target,
+			out: at,
+			duration: at - target.in,
+			selected: true,
+			masterSegmentIndex: undefined // sub-range of a master scene
+		}
+		const right: Clip = {
+			...target,
+			id: uuidv4(),
+			in: at,
+			duration: target.out - at,
+			selected: true,
+			masterSegmentIndex: undefined
+		}
+
+		const clips = asset.clips.flatMap((c) => (c.id === clipId ? [left, right] : [c]))
+		return { clips: reindexClips(clips) }
+	})
+
+	return getUpdatedAsset(threadId, assetId)
+}
+
+/**
+ * Remove derived Gemini data (transcript or scene descriptions) from ONE
+ * asset: deletes the backing JSON, clears the preprocessing path fields and
+ * the derived clip field (text / visual), and drops the step's task so the
+ * Inspector offers to re-run. The pieces (segmentation) are kept.
+ */
+export async function clearAssetData(
+	threadId: string,
+	assetId: string,
+	kind: 'transcript' | 'descriptions'
+): Promise<MediaAsset | null> {
+	const asset = getUpdatedAsset(threadId, assetId)
+	if (!asset) return null
+
+	// Delete the backing files (best-effort). Audio is intentionally kept so a
+	// later re-transcribe can skip re-extraction.
+	const thread = threadManager.getThread(threadId)!
+	if (kind === 'transcript') {
+		// The transcripts dir holds only transcript artifacts (json + raw
+		// response txt) — remove it wholesale for a clean sweep.
+		const dir = path.join(getAssetDir(thread, assetId), THREAD_DIRS.TRANSCRIPTS)
+		if (fs.existsSync(dir)) {
+			try { fs.rmSync(dir, { recursive: true, force: true }) } catch (e) { console.error('[editor] clear transcript:', e) }
+		}
+	} else {
+		// The analysis dir also holds scenes.json (kept) — delete just the file.
+		const f = asset.preprocessing?.sceneDescriptionsPath
+		if (f && fs.existsSync(f)) {
+			try { fs.rmSync(f, { force: true }) } catch (e) { console.error('[editor] clear descriptions:', e) }
+		}
+	}
+
+	await threadManager.updateThreadWith(threadId, (t) => {
+		if (!t.editor) return null
+		const media = t.editor.media.map((a) => {
+			if (a.id !== assetId) return a
+			const preprocessing = { ...a.preprocessing }
+			if (kind === 'transcript') {
+				delete preprocessing.transcriptPath
+				delete preprocessing.rawTranscriptPath
+				delete preprocessing.correctedTranscriptPath
+			} else {
+				delete preprocessing.sceneDescriptionsPath
+			}
+			const clips = a.clips.map((c) =>
+				kind === 'transcript' ? { ...c, text: undefined } : { ...c, visual: undefined }
+			)
+			return { ...a, preprocessing, clips }
+		})
+		// Drop the step's namespaced task(s) so a re-run reads as fresh.
+		const backgroundTasks = { ...(t.backgroundTasks || {}) }
+		delete backgroundTasks[`${assetId}:${kind === 'transcript' ? 'transcript' : 'descriptions'}`]
+		return { editor: { ...t.editor, media }, backgroundTasks }
+	})
+
+	return getUpdatedAsset(threadId, assetId)
+}
+
+/**
+ * Removes an asset: aborts any live preprocessing, deletes its artifact dir,
+ * and drops the asset plus its clips, timeline items, and namespaced tasks.
+ */
+export async function removeAsset(threadId: string, assetId: string): Promise<boolean> {
+	abortAssetPreprocessing(threadId, assetId)
+
+	const thread = threadManager.getThread(threadId)
+	if (!thread || !thread.editor) return false
+
+	const assetDir = getAssetDir(thread, assetId)
+	if (fs.existsSync(assetDir)) {
+		try {
+			fs.rmSync(assetDir, { recursive: true, force: true })
+		} catch (error) {
+			console.error(`[editor] Failed to delete asset dir ${assetDir}:`, error)
+		}
+	}
+
+	const updated = await threadManager.updateThreadWith(threadId, (t) => {
+		if (!t.editor) return null
+
+		const backgroundTasks = { ...(t.backgroundTasks || {}) }
+		for (const taskId of Object.keys(backgroundTasks)) {
+			if (taskId.startsWith(`${assetId}:`)) delete backgroundTasks[taskId]
+		}
+
+		return {
+			editor: {
+				...t.editor,
+				media: t.editor.media.filter((a) => a.id !== assetId),
+				timeline: t.editor.timeline.filter((item) => item.sourceAssetId !== assetId)
+			},
+			backgroundTasks
+		}
+	})
+
+	return updated !== null
+}
diff --git a/src/main/editor/context.ts b/src/main/editor/context.ts
new file mode 100644
index 0000000..53728af
--- /dev/null
+++ b/src/main/editor/context.ts
@@ -0,0 +1,192 @@
+import type { EditorDocument, MediaAsset, TimelineItem } from '@shared/types'
+import { computeScope, type AiScope } from '@shared/ai-scope'
+import { itemDuration } from '@shared/timeline'
+
+/**
+ * Builds the prompt context text for the editor AI (PRD §5.7).
+ * Applies the degradation ladder so a multi-hour project always fits the
+ * budget — ending, if it must, in an EXPLICIT truncation flag (never silent).
+ */
+
+export const MAX_SCENES_PER_ASSET = 60      // ladder: 60 -> 30 -> 12
+export const VISUAL_MAX_CHARS = 160
+export const CONTEXT_CHAR_BUDGET = 120_000  // ~30k tokens
+export const OUTLINE_GIST_COUNT = 2
+
+export interface PromptContextResult {
+	contextText: string
+	scope: AiScope
+	tokenEstimate: number
+	truncated: boolean
+	thinContext: boolean
+}
+
+const fmt = (n: number) => Math.round(n * 100) / 100
+
+export function buildPromptContext(
+	doc: EditorDocument,
+	prompt: string,
+	opts: { selectedItemIds: string[]; playheadSec: number; widen?: 'chapter' | 'full' }
+): PromptContextResult {
+	const scope = computeScope({
+		timeline: doc.timeline,
+		markers: doc.markers || [],
+		selectedItemIds: opts.selectedItemIds,
+		playheadSec: opts.playheadSec,
+		mediaIds: doc.media.map((a) => a.id),
+		widen: opts.widen
+	})
+
+	const inScopeIds = new Set(scope.itemIds)
+	const inScopeItems = doc.timeline
+		.filter((i) => inScopeIds.has(i.id))
+		.sort((a, b) => a.timelineStart - b.timelineStart)
+	const scopeAssets = doc.media.filter((a) => scope.assetIds.includes(a.id))
+
+	const clipOf = (item: TimelineItem) =>
+		doc.media.find((a) => a.id === item.sourceAssetId)?.clips.find((c) => c.id === item.sourceClipId)
+
+	const thinContext = !scopeAssets.some((a) => a.clips.some((c) => !!c.visual))
+
+	// Degradation ladder state
+	let scenesCap = MAX_SCENES_PER_ASSET
+	let dropNeighborVisuals = false
+	let dropUnusedAssetScenes = false
+	let truncated = false
+
+	const usedAssetIds = new Set(inScopeItems.map((i) => i.sourceAssetId))
+	const selectedSet = new Set(opts.selectedItemIds)
+
+	const build = (): string => {
+		const lines: string[] = []
+
+		// ---- PROJECT ----
+		lines.push('PROJECT')
+		lines.push(`- Sequence: ${fmt(doc.timelineMeta.duration)}s, ${doc.timelineMeta.fps}fps, ${doc.timelineMeta.width}x${doc.timelineMeta.height}`)
+		for (const track of [...doc.tracks].sort((a, b) => a.order - b.order)) {
+			const flags = [track.locked && 'locked', track.muted && 'muted', track.hidden && 'hidden'].filter(Boolean).join(', ')
+			lines.push(`- Track ${track.id} "${track.name}" (${track.kind}${flags ? ', ' + flags : ''})`)
+		}
+		for (const asset of doc.media) {
+			const described = asset.clips.some((c) => !!c.visual)
+			lines.push(`- Asset ${asset.id} "${asset.name}" ${asset.kind} ${fmt(asset.metadata?.duration || 0)}s — ${asset.clips.length} scenes, descriptions: ${described ? 'yes' : 'no'}`)
+		}
+		lines.push('')
+
+		// ---- SCOPE ----
+		lines.push(`SCOPE: ${scope.label}`)
+		lines.push('')
+
+		// ---- TIMELINE OUTLINE (only when scoped narrower than full) ----
+		if (scope.kind !== 'full' && doc.timeline.length > 0) {
+			lines.push('TIMELINE OUTLINE')
+			const markers = [...(doc.markers || [])].sort((a, b) => a.time - b.time)
+			const totalEnd = doc.timelineMeta.duration || 0
+			const bounds: { t0: number; t1: number; label: string }[] = []
+			if (markers.length > 0) {
+				const cuts = [0, ...markers.map((m) => m.time), totalEnd]
+				for (let k = 0; k < cuts.length - 1; k++) {
+					if (cuts[k + 1] - cuts[k] < 0.5) continue
+					const label = k === 0 ? 'Intro' : markers[k - 1]?.label || `#${k}`
+					bounds.push({ t0: cuts[k], t1: cuts[k + 1], label })
+				}
+			} else {
+				for (let t = 0; t < totalEnd; t += 600) {
+					bounds.push({ t0: t, t1: Math.min(t + 600, totalEnd), label: `#${bounds.length + 1}` })
+				}
+			}
+			for (const b of bounds) {
+				const items = doc.timeline.filter((i) => i.timelineStart >= b.t0 && i.timelineStart < b.t1)
+				if (!items.length) continue
+				const dur = items.reduce((sum, i) => sum + itemDuration(i), 0)
+				const gists = items
+					.map((i) => clipOf(i)?.visual)
+					.filter(Boolean)
+					.slice(0, OUTLINE_GIST_COUNT)
+					.map((v) => `"${v!.slice(0, 120)}"`)
+					.join(' / ')
+				lines.push(`- Chapter "${b.label}" [${fmt(b.t0)}–${fmt(b.t1)}s]: ${items.length} items, ${fmt(dur)}s${gists ? `; gist: ${gists}` : ''}`)
+			}
+			lines.push('')
+		}
+
+		// ---- ITEMS IN SCOPE ----
+		const header = scope.kind === 'full' ? 'CURRENT TIMELINE' : `ITEMS IN SCOPE (${inScopeItems.length})`
+		lines.push(header)
+		if (inScopeItems.length === 0) {
+			lines.push('(empty — build a new cut from the available scenes)')
+		}
+		for (const item of inScopeItems) {
+			const track = doc.tracks.find((t) => t.id === item.trackId)
+			const clip = clipOf(item)
+			const showVisual = clip?.visual && (!dropNeighborVisuals || selectedSet.has(item.id) || scope.kind !== 'selection')
+			const visual = showVisual ? ` | ${clip!.visual!.slice(0, VISUAL_MAX_CHARS)}` : ''
+			lines.push(
+				`- ${item.id} | ${track?.name || '?'} | at ${fmt(item.timelineStart)}s | src ${fmt(item.in)}–${fmt(item.out)}s | ${item.speed}x | "${item.label || ''}"${visual}`
+			)
+		}
+		lines.push('')
+
+		// ---- AVAILABLE SCENES ----
+		lines.push('AVAILABLE SCENES (add material from here via addClips)')
+		for (const asset of scopeAssets) {
+			if (dropUnusedAssetScenes && !usedAssetIds.has(asset.id)) {
+				lines.push(`Asset ${asset.id} "${asset.name}": ${asset.clips.length} scenes omitted for brevity`)
+				continue
+			}
+			lines.push(`Asset ${asset.id} "${asset.name}" (${fmt(asset.metadata?.duration || 0)}s):`)
+			const clips = asset.clips
+			if (clips.length <= scenesCap) {
+				for (const clip of clips) {
+					const visual = clip.visual ? ` "${clip.visual.slice(0, VISUAL_MAX_CHARS)}"` : ''
+					lines.push(`- #${clip.index} [${fmt(clip.in)}–${fmt(clip.out)}s, ${fmt(clip.duration)}s]${visual}`)
+				}
+			} else {
+				// Always include scenes already used by in-scope items, then sample evenly
+				const usedSceneIds = new Set(inScopeItems.filter((i) => i.sourceAssetId === asset.id).map((i) => i.sourceClipId))
+				const used = clips.filter((c) => usedSceneIds.has(c.id))
+				const rest = clips.filter((c) => !usedSceneIds.has(c.id))
+				const budget = Math.max(scenesCap - used.length, 4)
+				const step = Math.max(1, Math.floor(rest.length / budget))
+				const sampled = rest.filter((_, i) => i % step === 0).slice(0, budget)
+				const shown = [...used, ...sampled].sort((a, b) => a.index - b.index)
+				for (const clip of shown) {
+					const visual = clip.visual ? ` "${clip.visual.slice(0, VISUAL_MAX_CHARS)}"` : ''
+					lines.push(`- #${clip.index} [${fmt(clip.in)}–${fmt(clip.out)}s, ${fmt(clip.duration)}s]${visual}`)
+				}
+				lines.push(`- … +${clips.length - shown.length} more scenes between ${fmt(clips[0].in)}s and ${fmt(clips[clips.length - 1].out)}s (evenly sampled above)`)
+			}
+		}
+		lines.push('')
+
+		// ---- USER REQUEST ----
+		lines.push('USER REQUEST')
+		lines.push(prompt)
+
+		return lines.join('\n')
+	}
+
+	// Degradation ladder until we fit the budget
+	let text = build()
+	if (text.length > CONTEXT_CHAR_BUDGET) { scenesCap = 30; text = build() }
+	if (text.length > CONTEXT_CHAR_BUDGET) { scenesCap = 12; text = build() }
+	if (text.length > CONTEXT_CHAR_BUDGET) { dropNeighborVisuals = true; text = build() }
+	if (text.length > CONTEXT_CHAR_BUDGET) { dropUnusedAssetScenes = true; text = build() }
+	if (text.length > CONTEXT_CHAR_BUDGET) {
+		// Final resort: hard-truncate — but never the ITEMS IN SCOPE section.
+		// AVAILABLE SCENES comes after ITEMS, so cutting the tail (before USER
+		// REQUEST) only loses scene listings.
+		const requestBlock = `\nUSER REQUEST\n${prompt}`
+		text = text.slice(0, CONTEXT_CHAR_BUDGET - requestBlock.length - 64) +
+			'\n[... scene listings truncated — long project ...]\n' + requestBlock
+		truncated = true
+	}
+
+	return {
+		contextText: text,
+		scope,
+		tokenEstimate: Math.round(text.length / 4),
+		truncated,
+		thinContext
+	}
+}
diff --git a/src/main/editor/history.ts b/src/main/editor/history.ts
new file mode 100644
index 0000000..b1a26bd
--- /dev/null
+++ b/src/main/editor/history.ts
@@ -0,0 +1,129 @@
+import { app } from 'electron'
+import fs from 'fs'
+import path from 'path'
+import type { EditorHistoryFile, EditorHistoryStep, TimelineSnapshot } from '@shared/types'
+import { threadManager } from '../threads'
+
+/**
+ * Undo/redo sidecar persistence for the timeline editor (PRD §6).
+ * History lives OUTSIDE threads/{id}.json so the debounced doc autosave is
+ * decoupled from history growth. The renderer is authoritative for applying
+ * diffs; this module only loads/appends/prunes and persists.
+ *
+ * The pointer of record is doc.historyRef.currentStepId (persisted with the
+ * doc in one atomic write); the sidecar's currentStepId is informational.
+ */
+
+const MAX_STEPS = 50
+
+function historyDir(): string {
+	return path.join(app.getPath('userData'), 'editor-history')
+}
+
+function historyPath(threadId: string): string {
+	return path.join(historyDir(), `${threadId}.json`)
+}
+
+function emptyHistory(threadId: string): EditorHistoryFile {
+	return { threadId, steps: [], keyframes: [], currentStepId: '' }
+}
+
+function writeHistory(file: EditorHistoryFile) {
+	const dir = historyDir()
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+	// Write-temp-then-rename so a crash mid-write can't corrupt the file.
+	const target = historyPath(file.threadId)
+	const temp = `${target}.tmp`
+	fs.writeFileSync(temp, JSON.stringify(file))
+	fs.renameSync(temp, target)
+}
+
+export function loadHistory(threadId: string): EditorHistoryFile {
+	const filePath = historyPath(threadId)
+	if (!fs.existsSync(filePath)) return emptyHistory(threadId)
+	try {
+		const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as EditorHistoryFile
+		if (!Array.isArray(parsed.steps)) return emptyHistory(threadId)
+		return { ...emptyHistory(threadId), ...parsed, threadId }
+	} catch (error) {
+		console.error(`[editor-history] Failed to read history for ${threadId}:`, error)
+		return emptyHistory(threadId)
+	}
+}
+
+/**
+ * Appends a step: truncates any redo branch after the current pointer,
+ * assigns a monotonic seq, enforces the ring cap, stores an optional
+ * keyframe, and moves the pointer to the new step.
+ * Returns the assigned seq + resulting step count (renderer mirrors the ring).
+ */
+export async function pushStep(
+	threadId: string,
+	step: EditorHistoryStep,
+	keyframe?: TimelineSnapshot
+): Promise<{ seq: number; stepCount: number }> {
+	const file = loadHistory(threadId)
+
+	// Kill the redo branch beyond the current pointer
+	const pointerIndex = file.steps.findIndex((s) => s.id === file.currentStepId)
+	if (pointerIndex !== -1 && pointerIndex < file.steps.length - 1) {
+		const removed = new Set(file.steps.slice(pointerIndex + 1).map((s) => s.id))
+		file.steps = file.steps.slice(0, pointerIndex + 1)
+		file.keyframes = file.keyframes.filter((k) => !removed.has(k.stepId))
+	} else if (pointerIndex === -1 && file.currentStepId === '' && file.steps.length > 0) {
+		// Pointer at pre-history root: everything is a redo branch — drop it
+		file.steps = []
+		file.keyframes = []
+	}
+
+	const seq = await threadManager.getNextVersion(threadId)
+	const stored: EditorHistoryStep = { ...step, seq }
+	file.steps.push(stored)
+
+	if (keyframe) {
+		file.keyframes.push({ ...keyframe, stepId: stored.id })
+	}
+
+	// Ring cap: evict oldest steps; keep the newest keyframe at-or-before the
+	// new oldest step as the replay baseline, drop older ones.
+	if (file.steps.length > MAX_STEPS) {
+		file.steps = file.steps.slice(file.steps.length - MAX_STEPS)
+		const oldestSeq = file.steps[0].seq
+		const validIds = new Set(file.steps.map((s) => s.id))
+		const baseline = file.keyframes
+			.filter((k) => !validIds.has(k.stepId))
+			.pop() // newest evicted keyframe becomes the baseline
+		file.keyframes = file.keyframes.filter((k) => validIds.has(k.stepId))
+		if (baseline) file.keyframes.unshift(baseline)
+		void oldestSeq
+	}
+
+	file.currentStepId = stored.id
+	writeHistory(file)
+	return { seq, stepCount: file.steps.length }
+}
+
+export function setPointer(threadId: string, currentStepId: string): boolean {
+	const file = loadHistory(threadId)
+	file.currentStepId = currentStepId
+	writeHistory(file)
+	return true
+}
+
+/**
+ * Wipes the fine-grained ring (used on revision switches: old steps' diffs
+ * were computed against pre-switch states — redoing them onto a switched
+ * snapshot would corrupt it, and a pointer-only reset would rehydrate them).
+ */
+export function clearHistory(threadId: string): void {
+	writeHistory(emptyHistory(threadId))
+}
+
+export function deleteHistory(threadId: string): void {
+	const filePath = historyPath(threadId)
+	try {
+		if (fs.existsSync(filePath)) fs.unlinkSync(filePath)
+	} catch (error) {
+		console.error(`[editor-history] Failed to delete history for ${threadId}:`, error)
+	}
+}
diff --git a/src/main/editor/preprocess.ts b/src/main/editor/preprocess.ts
new file mode 100644
index 0000000..e1f486f
--- /dev/null
+++ b/src/main/editor/preprocess.ts
@@ -0,0 +1,830 @@
+import fs from 'fs'
+import path from 'path'
+import { setMaxListeners } from 'events'
+import { v4 as uuidv4 } from 'uuid'
+import type { Clip, MediaAsset, SilenceRegion } from '@shared/types'
+import type { PipelineContext } from '../pipeline'
+import { threadManager } from '../threads'
+import { backgroundTaskManager } from '../tasks'
+import * as ffmpegAdapter from '../ffmpeg'
+import { SceneDetector, checkScenedetectAvailability, type Scene } from '../scenedetect'
+import * as extraction from '../pipeline/phases/extraction'
+import { ASSET_DIRS } from '../constants/paths'
+import { getAssetDir, patchAsset, patchAssetPreprocessing } from './assets'
+
+/**
+ * Per-asset preprocessing orchestrator for the timeline editor.
+ *
+ * Design (video-editor-prd.md §5.2/§7): a lean, editor-shaped step chain
+ * (proxy -> scenes -> thumbnails -> clips) calling the ffmpeg/scenedetect
+ * helpers directly, plus an OPT-IN Gemini descriptions step that reuses
+ * extraction.generateSceneDescription VERBATIM through an asset-scoped
+ * PipelineContext (tempDir = tempDir/media/<assetId>), leaving the chat
+ * preprocessing chains untouched.
+ *
+ * Task ids are namespaced `${assetId}:<step>` inside the existing
+ * thread.backgroundTasks + background-task-update broadcast.
+ */
+
+export type PreprocessStep =
+	'proxy' | 'scenes' | 'thumbnails' | 'descriptions' | 'audio' | 'transcript' | 'filmstrip' | 'segment'
+
+// Transcript runs UP FRONT (before scenes) so pieces derive from real speech
+// segments; scene detection stays as the fallback piece source for videos
+// with no usable transcript and for explicit sensitivity re-runs.
+const DEFAULT_STEPS: PreprocessStep[] = ['proxy', 'audio', 'transcript', 'scenes', 'thumbnails']
+
+// Audio-only assets have no picture: skip proxy/scenes/thumbnails/filmstrip.
+// Pieces come from a LOCAL, energy-based segmentation (silence split + interval
+// fallback for music) — no Gemini needed. Transcription stays opt-in (the
+// Transcribe button runs 'audio'+'transcript' on demand).
+const AUDIO_STEPS: PreprocessStep[] = ['segment']
+
+// Audio/transcript failures (missing Gemini key, quota) must not brick the
+// import — the chain continues and pieces fall back to scene detection.
+const SOFT_FAIL_STEPS: PreprocessStep[] = ['audio', 'transcript']
+
+export const SCENEDETECT_MISSING = 'scenedetect-missing'
+
+// ===== Concurrency cap (K=3) for ffmpeg/scenedetect-heavy work =====
+const MAX_CONCURRENT_HEAVY = 3
+let heavyRunning = 0
+const heavyQueue: Array<() => void> = []
+
+async function withHeavySlot<T>(fn: () => Promise<T>): Promise<T> {
+	if (heavyRunning >= MAX_CONCURRENT_HEAVY) {
+		await new Promise<void>((resolve) => heavyQueue.push(resolve))
+	}
+	heavyRunning++
+	try {
+		return await fn()
+	} finally {
+		heavyRunning--
+		const next = heavyQueue.shift()
+		if (next) next()
+	}
+}
+
+// ===== Abort registry =====
+const abortControllers = new Map<string, AbortController>()
+
+const abortKey = (threadId: string, assetId: string) => `${threadId}:${assetId}`
+
+export function abortAssetPreprocessing(threadId: string, assetId: string): void {
+	const key = abortKey(threadId, assetId)
+	const controller = abortControllers.get(key)
+	if (controller) {
+		controller.abort()
+		abortControllers.delete(key)
+	}
+}
+
+export function isAssetPreprocessing(threadId: string, assetId: string): boolean {
+	return abortControllers.has(abortKey(threadId, assetId))
+}
+
+// ===== Helpers =====
+
+function getAsset(threadId: string, assetId: string): MediaAsset | null {
+	const thread = threadManager.getThread(threadId)
+	return thread?.editor?.media.find((a) => a.id === assetId) || null
+}
+
+function exists(p?: string): boolean {
+	return !!p && fs.existsSync(p)
+}
+
+const taskId = (assetId: string, step: PreprocessStep) => `${assetId}:${step}`
+
+/**
+ * Throttled per-step progress reporter: every setTask persists the thread
+ * JSON and broadcasts, so noisy sources (ffmpeg/scenedetect ticks) are
+ * quantized to ≥5% jumps.
+ */
+function makeProgressReporter(threadId: string, assetId: string, step: PreprocessStep) {
+	let last = -1
+	return (percent: number, status?: string) => {
+		const p = Math.min(100, Math.max(0, Math.round(percent)))
+		if (p - last < 5 && p !== 100) return
+		last = p
+		void setTask(threadId, assetId, step, { state: 'running', progress: p, ...(status ? { status } : {}) })
+	}
+}
+
+/**
+ * Best-effort numeric progress from a phase's human status text — reused
+ * phases only report strings (e.g. "Converting to audio... 45%",
+ * "Analyzing scenes 51 to 100 / 418..."). Returns null when no number.
+ */
+function progressFromStatus(status: string): number | null {
+	const pct = status.match(/(\d{1,3})\s*%/)
+	if (pct) return Math.min(100, Number(pct[1]))
+	const count = status.match(/(\d+)\s*(?:to\s+(\d+))?\s*\/\s*(\d+)/)
+	if (count) {
+		const done = Number(count[2] ?? count[1])
+		const total = Number(count[3])
+		if (total > 0 && done <= total) return Math.round((done / total) * 100)
+	}
+	return null
+}
+
+async function setTask(
+	threadId: string,
+	assetId: string,
+	step: PreprocessStep,
+	updates: Parameters<typeof backgroundTaskManager.updateTask>[2]
+) {
+	await backgroundTaskManager.updateTask(threadId, taskId(assetId, step), {
+		name: step,
+		...updates
+	})
+}
+
+/**
+ * Asset-scoped PipelineContext bridge so existing pipeline phases
+ * (generateSceneDescription today; transcript phases later) run per-asset.
+ * Modeled on backgroundTaskManager.createMockContext, but all reads/writes
+ * target the MediaAsset record and the asset's artifact dir.
+ */
+function createAssetContext(
+	threadId: string,
+	assetId: string,
+	step: PreprocessStep,
+	signal: AbortSignal
+): PipelineContext {
+	const thread = threadManager.getThread(threadId)!
+	const asset = getAsset(threadId, assetId)!
+	const assetDir = getAssetDir(thread, assetId)
+
+	return {
+		threadId,
+		videoPath: asset.proxyPath || asset.originalPath,
+		tempDir: assetDir, // THREAD_DIRS.FRAMES/ANALYSIS joins inside phases land under the asset dir
+		get preprocessing() {
+			return getAsset(threadId, assetId)?.preprocessing || {}
+		},
+		messageId: `editor-${assetId}`,
+		context: '',
+		baseTimeline: undefined,
+		intentResult: undefined,
+		updateStatus: async (status: string) => {
+			const progress = progressFromStatus(status)
+			await setTask(threadId, assetId, step, {
+				state: 'running',
+				status,
+				...(progress !== null ? { progress } : {})
+			})
+		},
+		recordUsage: async (record) => {
+			await threadManager.updateThreadWith(threadId, (t) => ({
+				usageHistory: [...(t.usageHistory || []), { ...record, timestamp: Date.now() }]
+			}))
+		},
+		savePreprocessing: async (updates) => {
+			await patchAssetPreprocessing(threadId, assetId, updates)
+		},
+		waitForTask: async () => { },
+		next: () => { },
+		finish: async () => { },
+		fail: async (error: string) => {
+			await setTask(threadId, assetId, step, { state: 'error', error })
+		},
+		signal
+	}
+}
+
+// ===== Steps =====
+
+async function runProxyStep(threadId: string, assetId: string, signal: AbortSignal) {
+	const asset = getAsset(threadId, assetId)!
+	if (exists(asset.proxyPath)) {
+		await setTask(threadId, assetId, 'proxy', { state: 'completed', progress: 100 })
+		return
+	}
+
+	await setTask(threadId, assetId, 'proxy', { state: 'running', status: 'Creating 480p proxy…', progress: 0 })
+
+	const thread = threadManager.getThread(threadId)!
+	const proxyDir = path.join(getAssetDir(thread, assetId), ASSET_DIRS.PROXY)
+	if (!fs.existsSync(proxyDir)) fs.mkdirSync(proxyDir, { recursive: true })
+
+	let proxyPath: string
+	if (await ffmpegAdapter.isVideoLowResolution(asset.originalPath)) {
+		// Already <=480p — reuse the original as the proxy
+		proxyPath = asset.originalPath
+	} else {
+		proxyPath = await withHeavySlot(() =>
+			ffmpegAdapter.toLowResolution(
+				asset.originalPath,
+				proxyDir,
+				(percent) => setTask(threadId, assetId, 'proxy', { state: 'running', progress: percent }),
+				signal,
+				{ sourceFps: asset.metadata?.fps }
+			)
+		)
+	}
+
+	await patchAsset(threadId, assetId, { proxyPath })
+	await patchAssetPreprocessing(threadId, assetId, { lowResVideoPath: proxyPath })
+	await setTask(threadId, assetId, 'proxy', { state: 'completed', progress: 100 })
+}
+
+async function runScenesStep(
+	threadId: string,
+	assetId: string,
+	signal: AbortSignal,
+	threshold?: number
+) {
+	const asset = getAsset(threadId, assetId)!
+	const forceRerun = threshold !== undefined
+
+	if (!forceRerun && exists(asset.preprocessing.sceneTimesPath)) {
+		await setTask(threadId, assetId, 'scenes', { state: 'completed', progress: 100 })
+		return
+	}
+
+	await setTask(threadId, assetId, 'scenes', { state: 'running', status: 'Detecting scenes…', progress: 0 })
+	const reportScenes = makeProgressReporter(threadId, assetId, 'scenes')
+
+	const available = await checkScenedetectAvailability()
+	if (!available) {
+		throw new Error(SCENEDETECT_MISSING)
+	}
+
+	const thread = threadManager.getThread(threadId)!
+	const analysisDir = path.join(getAssetDir(thread, assetId), ASSET_DIRS.ANALYSIS)
+	if (!fs.existsSync(analysisDir)) fs.mkdirSync(analysisDir, { recursive: true })
+	const sceneTimesPath = path.join(analysisDir, 'scenes.json')
+
+	const detector = new SceneDetector()
+	const videoPath = asset.proxyPath || asset.originalPath
+	let scenes = await withHeavySlot(() =>
+		detector.detectScenes(videoPath, signal, threshold, (p) => reportScenes(p))
+	)
+
+	// A cut-less video (talking head, screen recording) can yield zero rows —
+	// fall back to a single whole-video scene so there is always one piece.
+	if (scenes.length === 0 && asset.metadata?.duration) {
+		scenes = [{ startTime: 0, endTime: asset.metadata.duration, duration: asset.metadata.duration }]
+	}
+
+	fs.writeFileSync(sceneTimesPath, JSON.stringify(scenes, null, 2))
+	await patchAssetPreprocessing(threadId, assetId, { sceneTimesPath })
+
+	// Pieces come from the TRANSCRIPT when one was derived earlier in the
+	// chain; scenes only produce pieces as the fallback (no transcript) or on
+	// an explicit sensitivity re-run (the user asked for scene pieces).
+	const hasClips = (getAsset(threadId, assetId)?.clips || []).length > 0
+	if (forceRerun || !hasClips) {
+		await deriveClips(threadId, assetId, scenes)
+	}
+
+	await setTask(threadId, assetId, 'scenes', {
+		state: 'completed',
+		progress: 100,
+		status: `${scenes.length} scenes detected`
+	})
+}
+
+/**
+ * Map Scene[] -> Clip[] on the asset, preserving renderer-owned `selected`
+ * and prior `visual`/`thumbnailPath` by (in,out) epsilon-match on re-runs.
+ */
+async function deriveClips(threadId: string, assetId: string, scenes: Scene[]) {
+	const EPSILON = 0.05
+	await patchAsset(threadId, assetId, (current) => {
+		const previous = current.clips || []
+		const clips: Clip[] = scenes.map((scene, i) => {
+			const match = previous.find(
+				(c) => Math.abs(c.in - scene.startTime) <= EPSILON && Math.abs(c.out - scene.endTime) <= EPSILON
+			)
+			return {
+				id: match?.id || uuidv4(),
+				sourceAssetId: assetId,
+				index: i + 1,
+				in: scene.startTime,
+				out: scene.endTime,
+				duration: scene.duration,
+				thumbnailPath: match?.thumbnailPath,
+				visual: match?.visual,
+				text: match?.text,
+				selected: match?.selected ?? false,
+				masterSegmentIndex: i + 1
+			}
+		})
+		return { clips }
+	})
+}
+
+// Audio segmentation tuning (§5.2 for audio).
+const AUDIO_SILENCE_DB = -30       // below this is "silence" for splitting
+const AUDIO_SILENCE_MIN = 0.6      // min silence gap (s) that forces a cut
+const AUDIO_MIN_PIECE = 1.0        // drop/merge pieces shorter than this
+const AUDIO_TARGET_PIECE = 20      // interval-fallback / max piece length (s)
+
+/**
+ * Divides an audio duration into CONTIGUOUS pieces (full coverage — silence is
+ * split, not removed; the Silence Finder handles removal). Cut points are the
+ * midpoints of silence gaps; long runs (music, long monologue) are subdivided
+ * into ~AUDIO_TARGET_PIECE chunks and slivers merge into their predecessor.
+ */
+export function segmentAudio(duration: number, silence: SilenceRegion[]): { in: number; out: number }[] {
+	const cuts = new Set<number>([0, duration])
+	for (const s of silence) {
+		const a = Math.max(0, Math.min(s.start, duration))
+		const b = Math.max(0, Math.min(s.end, duration))
+		const mid = (a + b) / 2
+		if (mid > AUDIO_MIN_PIECE && mid < duration - AUDIO_MIN_PIECE) cuts.add(mid)
+	}
+	const points = [...cuts].sort((x, y) => x - y)
+
+	// Contiguous pieces, then subdivide long ones (music → even chunks).
+	const pieces: { in: number; out: number }[] = []
+	for (let i = 0; i < points.length - 1; i++) {
+		const seg = { in: points[i], out: points[i + 1] }
+		const len = seg.out - seg.in
+		if (len <= AUDIO_TARGET_PIECE * 1.5) {
+			pieces.push(seg)
+		} else {
+			const n = Math.ceil(len / AUDIO_TARGET_PIECE)
+			const step = len / n
+			for (let k = 0; k < n; k++) {
+				pieces.push({ in: seg.in + k * step, out: k === n - 1 ? seg.out : seg.in + (k + 1) * step })
+			}
+		}
+	}
+
+	// Merge slivers into the previous piece so nothing is unusably short.
+	const merged: { in: number; out: number }[] = []
+	for (const p of pieces) {
+		if (merged.length && p.out - p.in < AUDIO_MIN_PIECE) {
+			merged[merged.length - 1].out = p.out
+		} else {
+			merged.push({ ...p })
+		}
+	}
+	return merged.length ? merged : [{ in: 0, out: duration }]
+}
+
+/**
+ * Local, energy-based audio segmentation (no Gemini): silence split + interval
+ * fallback, so speech splits at pauses and music splits into even chunks. Runs
+ * silencedetect on the source directly (audio-kind assets have no proxy).
+ */
+async function runSegmentStep(threadId: string, assetId: string, signal: AbortSignal) {
+	const asset = getAsset(threadId, assetId)!
+	const duration = asset.metadata?.duration || 0
+	if (duration <= 0) {
+		await setTask(threadId, assetId, 'segment', { state: 'completed', progress: 100, status: 'No audio duration' })
+		return
+	}
+
+	await setTask(threadId, assetId, 'segment', { state: 'running', status: 'Segmenting audio…', progress: 0 })
+	const reportSeg = makeProgressReporter(threadId, assetId, 'segment')
+
+	const src = exists(asset.preprocessing.audioPath) ? asset.preprocessing.audioPath! : asset.originalPath
+	let silence: SilenceRegion[] = []
+	try {
+		silence = await withHeavySlot(() =>
+			ffmpegAdapter.detectSilence(src, { noiseDb: AUDIO_SILENCE_DB, minDurationSec: AUDIO_SILENCE_MIN }, signal, (p) => reportSeg(p))
+		)
+	} catch (error) {
+		if (signal.aborted) throw new Error('Aborted')
+		console.warn(`[editor] silencedetect failed for audio ${assetId} — using interval chunks:`, error)
+	}
+
+	if (signal.aborted) throw new Error('Aborted')
+	const ranges = segmentAudio(duration, silence)
+	await patchAsset(threadId, assetId, {
+		clips: ranges.map((r, i) => ({
+			id: uuidv4(),
+			sourceAssetId: assetId,
+			index: i + 1,
+			in: r.in,
+			out: r.out,
+			duration: r.out - r.in,
+			selected: false
+		}))
+	})
+
+	await setTask(threadId, assetId, 'segment', { state: 'completed', progress: 100, status: `${ranges.length} pieces` })
+}
+
+/**
+ * Guarantees an audio asset has at least one placeable piece. When segmentation
+ * produced pieces this is a no-op; otherwise it creates one clip spanning the
+ * whole file (labelled by name) so the asset can always be dropped on the audio
+ * track. Non-audio assets are left to scene detection.
+ */
+async function ensureAudioHasClip(threadId: string, assetId: string): Promise<void> {
+	const asset = getAsset(threadId, assetId)
+	if (!asset || asset.kind !== 'audio') return
+	if ((asset.clips || []).length > 0) return
+	const duration = asset.metadata?.duration || 0
+	if (duration <= 0) return
+	await patchAsset(threadId, assetId, {
+		clips: [{
+			id: uuidv4(),
+			sourceAssetId: assetId,
+			index: 1,
+			in: 0,
+			out: duration,
+			duration,
+			selected: false
+		}]
+	})
+}
+
+// Gap handling for transcript-derived pieces — mirrors timeline/enrichment.ts
+// so silence between statements stays visible and selectable.
+const MIN_GAP_SEC = 0.5
+const MAX_GAP_CHUNK_SEC = 15.0
+
+/**
+ * Map the transcript -> Clip[]: one piece per spoken statement, plus
+ * "[Silence]" pieces over gaps, so the tray shows REAL editorial segments
+ * (what was said) instead of visual scene cuts. Prior clip props survive by
+ * (in,out) epsilon-match.
+ */
+async function deriveClipsFromTranscript(threadId: string, assetId: string): Promise<number> {
+	const asset = getAsset(threadId, assetId)
+	const transcriptPath = asset?.preprocessing.transcriptPath
+	if (!asset || !exists(transcriptPath)) return 0
+
+	const items: { start: string; end: string; text: string }[] =
+		JSON.parse(fs.readFileSync(transcriptPath!, 'utf-8'))
+	const duration = asset.metadata?.duration || 0
+
+	type Seg = { in: number; out: number; text?: string }
+	const segments: Seg[] = []
+	const pushGap = (from: number, to: number) => {
+		let cursor = from
+		while (to - cursor > MIN_GAP_SEC) {
+			const end = Math.min(cursor + MAX_GAP_CHUNK_SEC, to)
+			segments.push({ in: cursor, out: end, text: '[Silence]' })
+			cursor = end
+		}
+	}
+
+	let previousEnd = 0
+	for (const item of [...items].sort((a, b) => srtToSeconds(a.start) - srtToSeconds(b.start))) {
+		const start = srtToSeconds(item.start)
+		const end = srtToSeconds(item.end)
+		if (!(end > start)) continue
+		if (start - previousEnd > MIN_GAP_SEC) pushGap(previousEnd, start)
+		segments.push({ in: start, out: end, text: item.text })
+		previousEnd = Math.max(previousEnd, end)
+	}
+	if (duration - previousEnd > MIN_GAP_SEC) pushGap(previousEnd, duration)
+
+	if (segments.length === 0) return 0
+
+	const EPSILON = 0.05
+	await patchAsset(threadId, assetId, (current) => {
+		const previous = current.clips || []
+		const clips: Clip[] = segments.map((seg, i) => {
+			const match = previous.find(
+				(c) => Math.abs(c.in - seg.in) <= EPSILON && Math.abs(c.out - seg.out) <= EPSILON
+			)
+			return {
+				id: match?.id || uuidv4(),
+				sourceAssetId: assetId,
+				index: i + 1,
+				in: seg.in,
+				out: seg.out,
+				duration: seg.out - seg.in,
+				thumbnailPath: match?.thumbnailPath,
+				visual: match?.visual,
+				text: seg.text,
+				selected: match?.selected ?? false,
+				masterSegmentIndex: undefined // speech segments don't map to master scenes
+			}
+		})
+		return { clips }
+	})
+	return segments.length
+}
+
+async function runThumbnailsStep(threadId: string, assetId: string, signal: AbortSignal) {
+	const asset = getAsset(threadId, assetId)!
+	// Thumbnails follow the CLIPS (whatever derived them — transcript segments
+	// or scene detection), one midpoint frame per piece.
+	const targets = (asset.clips || []).map((c) => ({ id: c.id, midpoint: c.in + c.duration / 2 }))
+	if (targets.length === 0) {
+		await setTask(threadId, assetId, 'thumbnails', { state: 'completed', status: 'No pieces to thumbnail' })
+		return
+	}
+
+	const thread = threadManager.getThread(threadId)!
+	const framesDir = path.join(getAssetDir(thread, assetId), ASSET_DIRS.FRAMES)
+	if (!fs.existsSync(framesDir)) fs.mkdirSync(framesDir, { recursive: true })
+
+	await setTask(threadId, assetId, 'thumbnails', { state: 'running', status: 'Extracting thumbnails…', progress: 0 })
+
+	const videoPath = asset.proxyPath || asset.originalPath
+	const thumbnails = new Map<string, string>() // clipId -> framePath
+
+	// Patch finished thumbnails into the (already-derived) clips so tiles fill
+	// in progressively. Every updateTask/patchAsset persists the thread JSON,
+	// so both are THROTTLED to a batch cadence rather than per-frame.
+	const flushThumbnails = async () => {
+		await patchAsset(threadId, assetId, (current) => ({
+			clips: (current.clips || []).map((clip) =>
+				thumbnails.has(clip.id) ? { ...clip, thumbnailPath: thumbnails.get(clip.id) } : clip
+			)
+		}))
+	}
+
+	const BATCH = Math.max(1, Math.min(8, Math.floor(targets.length / 25) || 1))
+
+	await withHeavySlot(async () => {
+		for (let i = 0; i < targets.length; i++) {
+			if (signal.aborted) throw new Error('Aborted')
+			try {
+				// extractFrame filenames are deterministic (…_frame_<t>.jpg) — re-runs reuse them
+				const framePath = await ffmpegAdapter.extractFrame(videoPath, targets[i].midpoint, framesDir, signal)
+				thumbnails.set(targets[i].id, framePath)
+			} catch (error) {
+				if (signal.aborted) throw error
+				console.error(`[editor] Thumbnail failed for piece ${i} of asset ${assetId}:`, error)
+				// tolerate individual frame failures
+			}
+
+			const done = i + 1
+			if (done % BATCH === 0 || done === targets.length) {
+				await flushThumbnails()
+				await setTask(threadId, assetId, 'thumbnails', {
+					state: 'running',
+					status: `${done}/${targets.length} thumbnails`,
+					progress: Math.round((done / targets.length) * 100)
+				})
+			}
+		}
+	})
+
+	await setTask(threadId, assetId, 'thumbnails', { state: 'completed', progress: 100 })
+}
+
+async function runDescriptionsStep(threadId: string, assetId: string, signal: AbortSignal) {
+	const asset = getAsset(threadId, assetId)!
+	if (!exists(asset.preprocessing.sceneTimesPath)) {
+		throw new Error('Scenes must be detected before describing them.')
+	}
+
+	await setTask(threadId, assetId, 'descriptions', { state: 'running', status: 'Describing scenes…' })
+
+	// Reuse the existing pipeline phase VERBATIM through an asset-scoped context.
+	const context = createAssetContext(threadId, assetId, 'descriptions', signal)
+	await extraction.generateSceneDescription({}, context)
+
+	if (signal.aborted) throw new Error('Aborted')
+
+	// Merge generated descriptions back into the asset's clips (by scene index).
+	const descriptionsPath = getAsset(threadId, assetId)?.preprocessing.sceneDescriptionsPath
+	if (exists(descriptionsPath)) {
+		const descriptions: { index: number; description: string; framePath: string }[] =
+			JSON.parse(fs.readFileSync(descriptionsPath!, 'utf-8'))
+		const byIndex = new Map(descriptions.map((d) => [d.index, d]))
+
+		await patchAsset(threadId, assetId, (current) => ({
+			clips: (current.clips || []).map((clip) => {
+				const desc = byIndex.get(clip.index - 1) // descriptions are 0-based scene indices
+				return desc
+					? { ...clip, visual: desc.description, thumbnailPath: clip.thumbnailPath || desc.framePath }
+					: clip
+			})
+		}))
+	}
+
+	await setTask(threadId, assetId, 'descriptions', { state: 'completed', progress: 100 })
+}
+
+async function runAudioStep(threadId: string, assetId: string, signal: AbortSignal) {
+	const asset = getAsset(threadId, assetId)!
+	if (exists(asset.preprocessing.audioPath)) {
+		await setTask(threadId, assetId, 'audio', { state: 'completed', progress: 100 })
+		return
+	}
+
+	await setTask(threadId, assetId, 'audio', { state: 'running', status: 'Extracting audio…' })
+
+	// Reuse the existing extraction phase VERBATIM through an asset-scoped context.
+	const context = createAssetContext(threadId, assetId, 'audio', signal)
+	await withHeavySlot(async () => { await extraction.convertToAudio({}, context) })
+
+	if (signal.aborted) throw new Error('Aborted')
+	await setTask(threadId, assetId, 'audio', { state: 'completed', progress: 100 })
+}
+
+async function runTranscriptStep(threadId: string, assetId: string, signal: AbortSignal) {
+	const asset = getAsset(threadId, assetId)!
+	if (!exists(asset.preprocessing.audioPath)) {
+		throw new Error('Audio must be extracted before transcription.')
+	}
+
+	// A single Gemini call has no incremental signal — report honest stage
+	// milestones so the bar still moves: upload/transcribe → merge → done.
+	await setTask(threadId, assetId, 'transcript', {
+		state: 'running', status: 'Uploading audio & transcribing…', progress: 10
+	})
+
+	// Reuse the raw-transcript phase VERBATIM (single Gemini pass — the editor
+	// keeps transcription lean; the chat flow's corrected pass is not run here).
+	const context = createAssetContext(threadId, assetId, 'transcript', signal)
+	await extraction.extractRawTranscript({}, context)
+
+	if (signal.aborted) throw new Error('Aborted')
+
+	await setTask(threadId, assetId, 'transcript', {
+		state: 'running', status: 'Deriving pieces from speech…', progress: 85
+	})
+
+	// Fresh import (no pieces yet): pieces ARE the transcript segments.
+	// Existing scene pieces (sensitivity re-run, later re-transcribe): keep
+	// them and just fill their text by overlap.
+	const hasClips = (getAsset(threadId, assetId)?.clips || []).length > 0
+	if (hasClips) {
+		await mergeTranscriptIntoClips(threadId, assetId)
+	} else {
+		const derived = await deriveClipsFromTranscript(threadId, assetId)
+		if (derived === 0) {
+			// Empty/unusable transcript — scenes step will derive fallback pieces
+			await setTask(threadId, assetId, 'transcript', {
+				state: 'completed', progress: 100, status: 'No speech found — using scene pieces'
+			})
+			return
+		}
+		await setTask(threadId, assetId, 'transcript', {
+			state: 'completed', progress: 100, status: `${derived} speech segments`
+		})
+		return
+	}
+
+	await setTask(threadId, assetId, 'transcript', { state: 'completed', progress: 100 })
+}
+
+// Cap total strip frames per asset so a multi-hour source stays one bounded
+// pass (PRD §5.5/§8): interval = max(1s, duration/300).
+const FILMSTRIP_MAX_FRAMES = 300
+
+async function runFilmstripStep(threadId: string, assetId: string, signal: AbortSignal) {
+	const asset = getAsset(threadId, assetId)!
+	if (asset.filmstrip?.length) {
+		await setTask(threadId, assetId, 'filmstrip', { state: 'completed', progress: 100 })
+		return
+	}
+
+	await setTask(threadId, assetId, 'filmstrip', { state: 'running', status: 'Generating filmstrip…', progress: 0 })
+	const reportFilmstrip = makeProgressReporter(threadId, assetId, 'filmstrip')
+
+	const thread = threadManager.getThread(threadId)!
+	const stripDir = path.join(getAssetDir(thread, assetId), ASSET_DIRS.FRAMES, 'strip')
+	if (!fs.existsSync(stripDir)) fs.mkdirSync(stripDir, { recursive: true })
+
+	const duration = asset.metadata?.duration || 0
+	const intervalSec = Math.max(1, duration / FILMSTRIP_MAX_FRAMES)
+	const videoPath = asset.proxyPath || asset.originalPath
+
+	const filmstrip = await withHeavySlot(() =>
+		ffmpegAdapter.generateFilmstrip(videoPath, stripDir, intervalSec, signal, (p) => reportFilmstrip(p))
+	)
+
+	await patchAsset(threadId, assetId, { filmstrip })
+	await setTask(threadId, assetId, 'filmstrip', {
+		state: 'completed',
+		progress: 100,
+		status: `${filmstrip.length} frames`
+	})
+}
+
+/** `HH:MM:SS,mmm` (or `MM:SS,mmm`) → seconds. Mirrors enrichment.ts timeToSeconds. */
+function srtToSeconds(t: string): number {
+	const clean = t.trim().replace(',', '.')
+	const [timePart, milliPart = '0'] = clean.split('.')
+	const parts = timePart.split(':').map(Number)
+	let seconds = 0
+	if (parts.length === 3) seconds = parts[0] * 3600 + parts[1] * 60 + parts[2]
+	else if (parts.length === 2) seconds = parts[0] * 60 + parts[1]
+	else seconds = parts[0] || 0
+	return seconds + parseFloat(`0.${milliPart}`)
+}
+
+/**
+ * Populate each Clip.text with the transcript excerpt overlapping [in, out].
+ * Mirrors the clip.visual merge in runDescriptionsStep, but keyed by time
+ * overlap rather than scene index (transcript segments don't align to scenes).
+ */
+async function mergeTranscriptIntoClips(threadId: string, assetId: string) {
+	const transcriptPath = getAsset(threadId, assetId)?.preprocessing.transcriptPath
+	if (!exists(transcriptPath)) return
+
+	const items: { start: string; end: string; text: string }[] =
+		JSON.parse(fs.readFileSync(transcriptPath!, 'utf-8'))
+	const ranges = items.map((it) => ({
+		start: srtToSeconds(it.start),
+		end: srtToSeconds(it.end),
+		text: (it.text || '').trim()
+	}))
+
+	await patchAsset(threadId, assetId, (current) => ({
+		clips: (current.clips || []).map((clip) => {
+			// Overlap test: item[s,e] intersects clip[in,out] when s < out && e > in.
+			const text = ranges
+				.filter((r) => r.start < clip.out && r.end > clip.in && r.text && r.text !== '[Silence]')
+				.map((r) => r.text)
+				.join(' ')
+				.trim()
+			return text ? { ...clip, text } : clip
+		})
+	}))
+}
+
+// ===== Orchestrator =====
+
+export async function preprocessMediaAsset(
+	threadId: string,
+	assetId: string,
+	options?: { steps?: PreprocessStep[]; threshold?: number }
+): Promise<void> {
+	const asset = getAsset(threadId, assetId)
+	if (!asset) return
+	if (isAssetPreprocessing(threadId, assetId)) return // already running
+
+	const steps = options?.steps?.length
+		? options.steps
+		: asset.kind === 'audio' ? AUDIO_STEPS : DEFAULT_STEPS
+	const controller = new AbortController()
+	// Every ffmpeg call (one per scene thumbnail) attaches an abort listener to
+	// this shared signal — lift Node's default cap of 10 to avoid leak warnings.
+	setMaxListeners(0, controller.signal)
+	abortControllers.set(abortKey(threadId, assetId), controller)
+	const { signal } = controller
+
+	await patchAsset(threadId, assetId, { preprocessState: 'running', preprocessError: undefined })
+
+	// Pre-register every step as pending so the UI shows the full checklist
+	// immediately and each bar visibly transitions pending -> running -> done.
+	for (const step of steps) {
+		await setTask(threadId, assetId, step, { state: 'pending', progress: 0, status: undefined, error: undefined })
+	}
+
+	let currentStep: PreprocessStep | null = null
+	try {
+		// A threshold re-run must re-detect scenes even if outputs exist
+		if (options?.threshold !== undefined) {
+			await patchAssetPreprocessing(threadId, assetId, { sceneTimesPath: undefined })
+		}
+
+		for (const step of steps) {
+			if (signal.aborted) throw new Error('Aborted')
+			currentStep = step
+			try {
+				switch (step) {
+					case 'proxy': await runProxyStep(threadId, assetId, signal); break
+					case 'scenes': await runScenesStep(threadId, assetId, signal, options?.threshold); break
+					case 'thumbnails': await runThumbnailsStep(threadId, assetId, signal); break
+					case 'descriptions': await runDescriptionsStep(threadId, assetId, signal); break
+					case 'audio': await runAudioStep(threadId, assetId, signal); break
+					case 'transcript': await runTranscriptStep(threadId, assetId, signal); break
+					case 'filmstrip': await runFilmstripStep(threadId, assetId, signal); break
+					case 'segment': await runSegmentStep(threadId, assetId, signal); break
+				}
+			} catch (stepError: any) {
+				// Audio/transcript are best-effort in the default chain: a missing
+				// Gemini key or quota error falls back to scene pieces instead of
+				// bricking the import. Everything else still hard-fails.
+				if (signal.aborted || !SOFT_FAIL_STEPS.includes(step)) throw stepError
+				const message = stepError?.message || `${step} failed`
+				console.warn(`[editor] ${step} failed for asset ${assetId} — continuing without it:`, message)
+				await setTask(threadId, assetId, step, { state: 'error', error: message })
+			}
+		}
+
+		// An audio asset with no transcript (no Gemini key / quota) derives zero
+		// pieces from the chain above — synthesize a single whole-file clip so it
+		// is always placeable on the audio track.
+		await ensureAudioHasClip(threadId, assetId)
+
+		await patchAsset(threadId, assetId, { preprocessState: 'completed' })
+	} catch (error: any) {
+		if (signal.aborted) {
+			// Asset removed or run cancelled — leave whatever state the removal left
+			console.log(`[editor] Preprocessing aborted for asset ${assetId}`)
+			return
+		}
+		const message = error?.message || 'Preprocessing failed'
+		console.error(`[editor] Preprocessing failed for asset ${assetId} (step: ${currentStep}):`, error)
+		// Mark the failed step's task and the asset errored; other assets are unaffected.
+		if (currentStep) {
+			await setTask(threadId, assetId, currentStep, { state: 'error', error: message })
+		}
+		await patchAsset(threadId, assetId, {
+			preprocessState: 'error',
+			preprocessError: message === SCENEDETECT_MISSING
+				? `${SCENEDETECT_MISSING}: PySceneDetect is not installed — scene splitting is unavailable.`
+				: message
+		})
+	} finally {
+		abortControllers.delete(abortKey(threadId, assetId))
+	}
+}
diff --git a/src/main/editor/prompt.ts b/src/main/editor/prompt.ts
new file mode 100644
index 0000000..ca43f1e
--- /dev/null
+++ b/src/main/editor/prompt.ts
@@ -0,0 +1,390 @@
+import { BrowserWindow } from 'electron'
+import { v4 as uuidv4 } from 'uuid'
+import type {
+	EditorDocument, EditorOps, EditorPersona, PromptTurn, Thread, TimelineDiff, TimelineItem
+} from '@shared/types'
+import { computeContentEnd, itemEnd, TIMELINE_DIFF_SCHEMA_VERSION } from '@shared/timeline'
+import { threadManager } from '../threads'
+import { settingsManager } from '../settings'
+import { GeminiAdapter } from '../gemini/adapter'
+import { GEMINI_MODEL_2_5_FLASH } from '../constants/gemini'
+import { BUILTIN_PERSONAS, DEFAULT_PERSONA_ID } from '../constants/personas'
+import { buildPromptContext } from './context'
+
+/**
+ * AI prompt orchestrator for the timeline editor (PRD §5.7).
+ * One structured Gemini call per turn: persona systemPrompt + fixed editor
+ * contract + windowed context -> EditorOps -> TimelineDiff (opsToDiff).
+ * Streams turn state over the dedicated `editor-turn-update` event.
+ * The base document is NEVER mutated here — the renderer applies the diff
+ * only on user accept (commitStep with origin 'ai').
+ */
+
+// ===== Ops schema (constrained on purpose — see EditorOps in shared/types) =====
+export const EDITOR_OPS_SCHEMA = {
+	type: 'object',
+	properties: {
+		answer: {
+			type: 'string',
+			description: 'Only when the request is a question — answer it and propose no operations'
+		},
+		rationale: {
+			type: 'string',
+			description: 'Plain-language explanation of the proposed edit, citing scene descriptions'
+		},
+		removeItemIds: { type: 'array', items: { type: 'string' } },
+		updateItems: {
+			type: 'array',
+			items: {
+				type: 'object',
+				properties: {
+					id: { type: 'string' },
+					timelineStart: { type: 'number' },
+					in: { type: 'number' },
+					out: { type: 'number' },
+					speed: { type: 'number' },
+					label: { type: 'string' }
+				},
+				required: ['id']
+			}
+		},
+		addClips: {
+			type: 'array',
+			items: {
+				type: 'object',
+				properties: {
+					assetId: { type: 'string' },
+					sceneIndex: { type: 'integer', description: "A scene # from that asset's AVAILABLE SCENES list" },
+					in: { type: 'number' },
+					out: { type: 'number' },
+					atSec: { type: 'number' },
+					afterItemId: { type: 'string' },
+					label: { type: 'string' }
+				},
+				required: ['assetId']
+			}
+		},
+		addMarkers: {
+			type: 'array',
+			items: {
+				type: 'object',
+				properties: {
+					atSec: { type: 'number' },
+					label: { type: 'string' }
+				},
+				required: ['atSec', 'label']
+			}
+		}
+	}
+}
+
+// ===== System instruction composition =====
+export function composeSystemInstruction(persona: EditorPersona): string {
+	const defaults = persona.defaults || {}
+	const durationLine = defaults.targetDurationSec != null
+		? `Target output duration: about ${defaults.targetDurationSec} seconds. Cut toward this target.`
+		: 'No length target — PRESERVE the full runtime. Make editorial improvements (remove dead air, tighten with retime, reorder, chapter) without shrinking the substantive content.'
+
+	return [
+		persona.systemPrompt,
+		'',
+		'=== EDITOR CONTRACT (always applies) ===',
+		'You are proposing an edit to a video timeline in a non-linear editor. You receive the',
+		"current timeline items (each with a stable id), the project's media assets with their",
+		'detected scenes, and a user request.',
+		'- If the request is a QUESTION about the project, put the answer in `answer` and',
+		'  propose no operations.',
+		'- Otherwise propose ONE coherent edit:',
+		'  - Reference existing timeline items ONLY by their exact `id` from the items list.',
+		'  - Add new material ONLY via `addClips`, referencing an `assetId` plus a scene `#`',
+		"    from that asset's AVAILABLE SCENES list (preferred), or explicit in/out seconds",
+		"    within the asset's duration.",
+		'  - Never invent ids or scene numbers. All times are seconds.',
+		'  - `updateItems` may change timelineStart, in, out, speed (0.25-4.0), label.',
+		'    Never set durations — they are derived from (out - in) / speed.',
+		'  - Only modify items listed in the items section.',
+		'- Always include a short `rationale` describing what you changed and why, citing',
+		'  scene descriptions where available.',
+		'',
+		'=== ACTIVE PERSONA DEFAULTS ===',
+		`Tone: ${persona.tone || 'neutral'}. Pacing: ${defaults.pacing || 'balanced'}.`,
+		durationLine,
+		defaults.aspectRatio ? `Target aspect ratio: ${defaults.aspectRatio}.` : ''
+	].filter(Boolean).join('\n')
+}
+
+// ===== Ops -> TimelineDiff mapping =====
+export function opsToDiff(
+	ops: EditorOps,
+	doc: EditorDocument
+): { diff: TimelineDiff; addMarkers: { time: number; label: string }[]; droppedOps: string[] } {
+	const droppedOps: string[] = []
+	const diff: TimelineDiff = { schemaVersion: TIMELINE_DIFF_SCHEMA_VERSION }
+	const itemIds = new Set(doc.timeline.map((i) => i.id))
+
+	// Removals
+	if (ops.removeItemIds?.length) {
+		const known = ops.removeItemIds.filter((id) => itemIds.has(id))
+		for (const id of ops.removeItemIds) {
+			if (!itemIds.has(id)) droppedOps.push(`remove: unknown item ${id}`)
+		}
+		if (known.length) diff.removeItemIds = known
+	}
+
+	// Updates (whitelist fields; validation happens in applyTimelineDiff)
+	if (ops.updateItems?.length) {
+		const updates: NonNullable<TimelineDiff['updateItems']> = []
+		for (const update of ops.updateItems) {
+			if (!itemIds.has(update.id)) {
+				droppedOps.push(`update: unknown item ${update.id}`)
+				continue
+			}
+			const clean: { id: string } & Partial<TimelineItem> = { id: update.id }
+			if (typeof update.timelineStart === 'number') clean.timelineStart = update.timelineStart
+			if (typeof update.in === 'number') clean.in = update.in
+			if (typeof update.out === 'number') clean.out = update.out
+			if (typeof update.speed === 'number') clean.speed = update.speed
+			if (typeof update.label === 'string') clean.label = update.label
+			if (Object.keys(clean).length > 1) updates.push(clean)
+		}
+		if (updates.length) diff.updateItems = updates
+	}
+
+	// Adds: resolve asset + scene references; ids generated HERE, never by the model
+	if (ops.addClips?.length) {
+		const adds: TimelineItem[] = []
+		// Sequential placement cursor for adds without explicit position
+		let appendCursor = computeContentEnd(doc.timeline)
+		const targetTrack = [...doc.tracks]
+			.sort((a, b) => a.order - b.order)
+			.find((t) => t.kind === 'video' && !t.locked && !t.hidden)
+
+		for (const add of ops.addClips) {
+			const asset = doc.media.find((a) => a.id === add.assetId)
+			if (!asset) {
+				droppedOps.push(`add: unknown asset ${add.assetId}`)
+				continue
+			}
+			if (!targetTrack) {
+				droppedOps.push('add: no unlocked video track available')
+				break
+			}
+
+			let sourceIn: number | undefined
+			let sourceOut: number | undefined
+			let sourceClipId: string | undefined
+			let masterSegmentIndex: number | undefined
+			let label = add.label
+
+			if (typeof add.sceneIndex === 'number') {
+				const clip = asset.clips.find((c) => c.index === add.sceneIndex)
+				if (!clip) {
+					droppedOps.push(`add: unknown scene #${add.sceneIndex} of ${asset.name}`)
+					continue
+				}
+				sourceIn = clip.in
+				sourceOut = clip.out
+				sourceClipId = clip.id
+				masterSegmentIndex = clip.masterSegmentIndex
+				label = label || clip.visual?.slice(0, 40) || `Piece #${clip.index}`
+			} else if (typeof add.in === 'number' && typeof add.out === 'number') {
+				const assetDuration = asset.metadata?.duration ?? Number.POSITIVE_INFINITY
+				if (!(add.in >= 0 && add.out > add.in && add.out <= assetDuration + 0.01)) {
+					droppedOps.push(`add: invalid range ${add.in}-${add.out} for ${asset.name}`)
+					continue
+				}
+				sourceIn = add.in
+				sourceOut = add.out
+				label = label || asset.name
+			} else {
+				droppedOps.push(`add: neither sceneIndex nor in/out given for ${asset.name}`)
+				continue
+			}
+
+			// Placement: explicit atSec > after a known item > append at end
+			let timelineStart: number
+			if (typeof add.atSec === 'number' && add.atSec >= 0) {
+				timelineStart = add.atSec
+			} else if (add.afterItemId && itemIds.has(add.afterItemId)) {
+				const anchor = doc.timeline.find((i) => i.id === add.afterItemId)!
+				timelineStart = itemEnd(anchor)
+			} else {
+				timelineStart = appendCursor
+			}
+
+			const duration = sourceOut! - sourceIn!
+			adds.push({
+				id: uuidv4(),
+				trackId: targetTrack.id,
+				sourceAssetId: asset.id,
+				sourceClipId,
+				masterSegmentIndex,
+				timelineStart,
+				in: sourceIn!,
+				out: sourceOut!,
+				speed: 1.0,
+				preservePitch: true,
+				duration,
+				label
+			})
+			appendCursor = Math.max(appendCursor, timelineStart + duration)
+		}
+		if (adds.length) diff.addItems = adds
+	}
+
+	const addMarkers = (ops.addMarkers || [])
+		.filter((m) => typeof m.atSec === 'number' && m.atSec >= 0 && m.label)
+		.map((m) => ({ time: m.atSec, label: m.label }))
+
+	return { diff, addMarkers, droppedOps }
+}
+
+// ===== Turn lifecycle =====
+const turnControllers = new Map<string, AbortController>()
+
+function emitTurnUpdate(payload: {
+	threadId: string
+	turn: PromptTurn
+	addMarkers?: { time: number; label: string }[]
+	thinContext?: boolean
+	truncated?: boolean
+}) {
+	BrowserWindow.getAllWindows().forEach((win) => {
+		win.webContents.send('editor-turn-update', payload)
+	})
+}
+
+async function persistTurn(threadId: string, turn: PromptTurn): Promise<void> {
+	await threadManager.updateThreadWith(threadId, (thread) => {
+		if (!thread.editor) return null
+		const turns = [...thread.editor.turns]
+		const index = turns.findIndex((t) => t.id === turn.id)
+		if (index === -1) turns.push(turn)
+		else turns[index] = turn
+		return { editor: { ...thread.editor, turns } }
+	})
+}
+
+function resolvePersona(doc: EditorDocument, personaId: string): EditorPersona {
+	return (
+		doc.customPersonas?.find((p) => p.id === personaId) ||
+		settingsManager.getPersonas().find((p) => p.id === personaId) ||
+		BUILTIN_PERSONAS.find((p) => p.id === personaId) ||
+		BUILTIN_PERSONAS.find((p) => p.id === DEFAULT_PERSONA_ID)!
+	)
+}
+
+export function abortEditorPrompt(turnId: string): void {
+	const controller = turnControllers.get(turnId)
+	if (controller) {
+		controller.abort()
+		turnControllers.delete(turnId)
+	}
+}
+
+/**
+ * Runs one prompt turn. Returns the turnId immediately; work continues async
+ * and streams over `editor-turn-update`.
+ */
+export function runEditorPrompt(options: {
+	threadId: string
+	personaId: string
+	prompt: string
+	baseStepId: string
+	selectedItemIds: string[]
+	playheadSec: number
+	widen?: 'chapter' | 'full'
+}): { turnId: string } {
+	const { threadId, personaId, prompt, baseStepId } = options
+	const turnId = uuidv4()
+
+	const turn: PromptTurn = {
+		id: turnId,
+		personaId,
+		prompt,
+		baseStepId,
+		status: 'running',
+		createdAt: Date.now()
+	}
+
+	// Async body — errors land on the turn record, never thrown to the caller
+	void (async () => {
+		const controller = new AbortController()
+		turnControllers.set(turnId, controller)
+		try {
+			const thread: Thread | null = threadManager.getThread(threadId)
+			if (!thread || thread.type !== 'editor' || !thread.editor) {
+				throw new Error('Not an editor project')
+			}
+			if (thread.editor.media.length === 0) {
+				throw new Error('Import media before prompting')
+			}
+			const doc = thread.editor
+
+			await persistTurn(threadId, turn)
+			emitTurnUpdate({ threadId, turn })
+
+			const persona = resolvePersona(doc, personaId)
+			const context = buildPromptContext(doc, prompt, {
+				selectedItemIds: options.selectedItemIds,
+				playheadSec: options.playheadSec,
+				widen: options.widen
+			})
+
+			const modelSettings = settingsManager.getModelSettings()
+			const modelName = modelSettings.selection['editor-edit'] || GEMINI_MODEL_2_5_FLASH
+
+			const adapter = GeminiAdapter.create()
+			const { data: ops, record } = await adapter.generateStructuredText<EditorOps>(
+				modelName,
+				context.contextText,
+				EDITOR_OPS_SCHEMA,
+				composeSystemInstruction(persona),
+				controller.signal
+			)
+
+			// Record usage/cost at project level
+			await threadManager.updateThreadWith(threadId, (t) => ({
+				usageHistory: [...(t.usageHistory || []), { ...record, timestamp: Date.now() }]
+			}))
+
+			if (controller.signal.aborted) throw new Error('Cancelled')
+
+			// Map ops against a FRESH read (doc may have advanced during the call);
+			// the renderer re-validates against ITS live doc anyway.
+			const freshDoc = threadManager.getThread(threadId)?.editor || doc
+			const { diff, addMarkers, droppedOps } = opsToDiff(ops || {}, freshDoc)
+
+			const completed: PromptTurn = {
+				...turn,
+				status: 'completed',
+				diff,
+				rationale: ops?.rationale,
+				answer: ops?.answer,
+				droppedOps: droppedOps.length ? droppedOps : undefined,
+				scopeLabel: context.scope.label,
+				usage: record.usage,
+				cost: record.cost
+			}
+			await persistTurn(threadId, completed)
+			emitTurnUpdate({
+				threadId,
+				turn: completed,
+				addMarkers,
+				thinContext: context.thinContext,
+				truncated: context.truncated
+			})
+		} catch (error: any) {
+			const message = controller.signal.aborted ? 'Cancelled' : (error?.message || 'Prompt failed')
+			const failed: PromptTurn = { ...turn, status: 'error', error: message }
+			try {
+				await persistTurn(threadId, failed)
+			} catch { /* best effort */ }
+			emitTurnUpdate({ threadId, turn: failed })
+		} finally {
+			turnControllers.delete(turnId)
+		}
+	})()
+
+	return { turnId }
+}
diff --git a/src/main/editor/render.ts b/src/main/editor/render.ts
new file mode 100644
index 0000000..e19d59f
--- /dev/null
+++ b/src/main/editor/render.ts
@@ -0,0 +1,502 @@
+import { BrowserWindow } from 'electron'
+import ffmpeg from 'fluent-ffmpeg'
+import fs from 'fs'
+import path from 'path'
+import process from 'node:process'
+import { v4 as uuidv4 } from 'uuid'
+import type {
+	EditorDocument, EditorRenderProgress, ExportQuality, MediaAsset,
+	TimelineItem, TimelineSegment, Track
+} from '@shared/types'
+import { itemEnd } from '@shared/timeline'
+import { threadManager } from '../threads'
+import { assembleVideo, sanitizeFilename } from '../ffmpeg'
+import { THREAD_DIRS } from '../constants/paths'
+
+/**
+ * Export render engine (PRD §5.9 / §7 option C — segment-then-concat).
+ *
+ * Fast path: a single-source, speed-1, unmuted, gapless timeline maps to
+ * TimelineSegment[] and reuses assembleVideo unchanged.
+ *
+ * Region path: the sequence is sliced at clip boundaries into regions
+ * (clip | gap); each region renders to a UNIFORM mp4 intermediate
+ * (h264 + aac 48kHz stereo, normalized W×H/FPS, both streams always
+ * present), then the concat demuxer stitches with -c copy. Per-item
+ * speed renders via setpts + chained atempo (or asetrate when
+ * preservePitch=false). Gaps render black + silence.
+ *
+ * The region model carries audioSources[] (0..1 entries today) so the
+ * P2 multi-source amix graph slots in without reshaping.
+ */
+
+const IS_MAC = process.platform === 'darwin'
+const GAP_EPS = 0.05
+
+// ===== Region model =====
+// Regions are sliced at the UNION of every video- AND audio-item boundary, so
+// each region is fully covered (or not) by each item — never partially. A
+// region carries at most one video slice (the primary video track) plus any
+// number of active audio sources (the video's own audio + audio-track items),
+// mixed to one stereo output at render time (§5.9).
+
+interface VideoSlice {
+	srcPath: string
+	in: number
+	out: number
+	speed: number
+}
+
+interface AudioSource {
+	srcPath: string
+	in: number
+	out: number
+	speed: number
+	preservePitch: boolean
+	gain: number
+}
+
+interface Region {
+	duration: number
+	video: VideoSlice | null   // null → black frames of `duration`
+	audioSources: AudioSource[] // empty → silence of `duration`
+}
+
+interface RegionPlan {
+	regions: Region[]
+	width: number
+	height: number
+	fps: number
+}
+
+/** Map a covering item's source range onto a sub-region [t0,t1) of the timeline. */
+function sliceSource(item: TimelineItem, t0: number, t1: number): { in: number; out: number; speed: number } {
+	const speed = item.speed || 1
+	return {
+		in: item.in + (t0 - item.timelineStart) * speed,
+		out: item.in + (t1 - item.timelineStart) * speed,
+		speed
+	}
+}
+
+export function computeRegions(doc: EditorDocument, quality: ExportQuality): RegionPlan {
+	const videoTrack = doc.tracks
+		.filter((t) => t.kind === 'video' && !t.hidden)
+		.sort((a, b) => a.order - b.order)[0] || null
+	const audioTrackById = new Map(
+		doc.tracks.filter((t) => t.kind === 'audio' && !t.hidden).map((t) => [t.id, t])
+	)
+
+	const videoItems = videoTrack
+		? doc.timeline.filter((i) => i.trackId === videoTrack.id).sort((a, b) => a.timelineStart - b.timelineStart)
+		: []
+	const audioItems = doc.timeline
+		.filter((i) => audioTrackById.has(i.trackId))
+		.sort((a, b) => a.timelineStart - b.timelineStart)
+
+	if (videoItems.length === 0 && audioItems.length === 0) {
+		throw new Error('Nothing to export — the timeline is empty.')
+	}
+
+	const assetById = new Map(doc.media.map((a) => [a.id, a]))
+	const srcFor = (asset: MediaAsset) =>
+		quality === 'preview' ? (asset.proxyPath || asset.originalPath) : asset.originalPath
+
+	// Normalization target: derived from the VIDEO assets in use (audio assets
+	// carry no picture). Defaults keep an audio-only export at a sane 720p.
+	const usedVideoAssets = [...new Set(videoItems.map((i) => i.sourceAssetId))]
+		.map((id) => assetById.get(id))
+		.filter((a): a is MediaAsset => !!a)
+	const even = (n: number) => Math.max(2, Math.floor(n / 2) * 2)
+	const largest = usedVideoAssets.reduce((best, a) => {
+		const area = (a.metadata?.width || 0) * (a.metadata?.height || 0)
+		return area > best.area ? { area, w: a.metadata!.width, h: a.metadata!.height } : best
+	}, { area: 0, w: 1280, h: 720 })
+	const width = even(largest.w)
+	const height = even(largest.h)
+	const fps = Math.min(60, Math.max(10,
+		usedVideoAssets.reduce((max, a) => Math.max(max, a.metadata?.fps || 0), 0) || 30
+	))
+
+	// Boundary set = every video- and audio-item edge, clamped to [0, end].
+	const allItems = [...videoItems, ...audioItems]
+	const end = allItems.reduce((max, it) => Math.max(max, itemEnd(it)), 0)
+	const cuts = new Set<number>([0, end])
+	for (const it of allItems) {
+		cuts.add(Math.min(Math.max(it.timelineStart, 0), end))
+		cuts.add(Math.min(Math.max(itemEnd(it), 0), end))
+	}
+	const points = [...cuts].sort((a, b) => a - b)
+
+	// A video item's own audio contributes when unmuted and the source has audio.
+	const videoAudioActive = (item: TimelineItem, asset: MediaAsset) =>
+		!item.muted && !(videoTrack?.muted) && asset.metadata?.hasAudio !== false
+	// An audio-track item contributes when neither it nor its track is muted.
+	const audioItemActive = (item: TimelineItem) =>
+		!item.muted && !audioTrackById.get(item.trackId)?.muted
+
+	const covers = (item: TimelineItem, t0: number, t1: number) =>
+		item.timelineStart <= t0 + GAP_EPS && itemEnd(item) >= t1 - GAP_EPS
+
+	const regions: Region[] = []
+	for (let i = 0; i < points.length - 1; i++) {
+		const t0 = points[i]
+		const t1 = points[i + 1]
+		const duration = t1 - t0
+		if (duration <= GAP_EPS) continue
+
+		// ---- Video: the single covering video-track item (if any) ----
+		let video: VideoSlice | null = null
+		const vItem = videoItems.find((it) => covers(it, t0, t1))
+		if (vItem) {
+			const asset = assetById.get(vItem.sourceAssetId)
+			if (!asset) throw new Error(`Missing media asset for clip "${vItem.label || vItem.id}".`)
+			const slice = sliceSource(vItem, t0, t1)
+			video = { srcPath: srcFor(asset), in: slice.in, out: slice.out, speed: slice.speed }
+		}
+
+		// ---- Audio: video's own audio + every covering audio-track item ----
+		const audioSources: AudioSource[] = []
+		if (vItem) {
+			const asset = assetById.get(vItem.sourceAssetId)!
+			if (videoAudioActive(vItem, asset)) {
+				const slice = sliceSource(vItem, t0, t1)
+				audioSources.push({
+					srcPath: srcFor(asset), in: slice.in, out: slice.out,
+					speed: slice.speed, preservePitch: vItem.preservePitch !== false, gain: vItem.gain ?? 1
+				})
+			}
+		}
+		for (const aItem of audioItems) {
+			if (!covers(aItem, t0, t1) || !audioItemActive(aItem)) continue
+			const asset = assetById.get(aItem.sourceAssetId)
+			if (!asset) continue
+			const slice = sliceSource(aItem, t0, t1)
+			audioSources.push({
+				srcPath: srcFor(asset), in: slice.in, out: slice.out,
+				speed: slice.speed, preservePitch: aItem.preservePitch !== false, gain: aItem.gain ?? 1
+			})
+		}
+
+		regions.push({ duration, video, audioSources })
+	}
+
+	return { regions, width, height, fps }
+}
+
+// ===== Fast path =====
+
+export function isFastPathEligible(items: TimelineItem[], track: Track, hasAudioItems = false): boolean {
+	if (items.length === 0) return false
+	if (hasAudioItems) return false // audio-track items need the mixing region path
+	if (track.muted || track.hidden) return false // assembleVideo can't drop audio
+	const srcId = items[0].sourceAssetId
+	if (!items.every((i) => i.sourceAssetId === srcId)) return false
+	if (!items.every((i) => (i.speed ?? 1) === 1)) return false // no setpts in assembleVideo
+	if (items.some((i) => i.muted)) return false
+	if (Math.abs(items[0].timelineStart) > GAP_EPS) return false // leading gap needs black
+	for (let i = 1; i < items.length; i++) {
+		if (Math.abs(items[i].timelineStart - itemEnd(items[i - 1])) > GAP_EPS) return false
+	}
+	return true
+}
+
+// ===== ffmpeg building blocks =====
+
+const vnorm = (w: number, h: number, fps: number) =>
+	`scale=${w}:${h}:force_original_aspect_ratio=decrease,` +
+	`pad=${w}:${h}:(ow-iw)/2:(oh-ih)/2,setsar=1,fps=${fps},format=yuv420p`
+
+/** Chain atempo stages so each stays within ffmpeg's 0.5–2.0 range. */
+export function atempoChain(speed: number): string {
+	const stages: number[] = []
+	let factor = speed
+	while (factor > 2) { stages.push(2); factor /= 2 }
+	while (factor < 0.5) { stages.push(0.5); factor /= 0.5 }
+	stages.push(factor)
+	return stages.map((s) => `atempo=${s.toFixed(4).replace(/0+$/, '').replace(/\.$/, '')}`).join(',')
+}
+
+// Uniform intermediates: identical codec/res/fps/rate/layout is REQUIRED for
+// concat -c copy. Forced h264+aac mp4 on all platforms (incl. webm sources).
+const intermediateOpts = (): string[] => [
+	...(IS_MAC
+		? ['-c:v', 'h264_videotoolbox', '-b:v', '8M', '-realtime', 'true']
+		: ['-c:v', 'libx264', '-preset', 'veryfast', '-crf', '18']),
+	'-c:a', 'aac', '-b:a', '192k', '-ar', '48000', '-ac', '2',
+	'-video_track_timescale', '90000',
+	'-threads', '0'
+]
+
+function runCommand(
+	command: ffmpeg.FfmpegCommand,
+	outputPath: string,
+	signal: AbortSignal,
+	onProgress?: (percent: number) => void
+): Promise<void> {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) return reject(new Error('aborted'))
+		signal.addEventListener('abort', () => command.kill('SIGKILL'))
+		command
+			.output(outputPath)
+			.on('start', (cmd) => console.log('[render] ffmpeg:', cmd))
+			.on('progress', (progress) => {
+				if (onProgress && progress.percent) onProgress(Math.min(100, Math.round(progress.percent)))
+			})
+			.on('end', () => resolve())
+			.on('error', (err, _stdout, stderr) => {
+				if (signal.aborted) return reject(new Error('aborted'))
+				console.error('[render] ffmpeg failed:', err?.message, stderr?.slice(-800))
+				reject(new Error(`Render step failed: ${err?.message || 'ffmpeg error'}`))
+			})
+			.run()
+	})
+}
+
+/**
+ * Renders ONE region to a uniform intermediate: a video slice (or black) plus
+ * the region's mixed audio. 0 audio sources → silence; 1 → that stream; k>1 →
+ * amix (normalize=0, gains already applied) so overlapping audio-track items
+ * and a video's own soundtrack mix correctly and stay region-length (§5.9).
+ */
+async function renderRegion(
+	region: Region,
+	index: number,
+	plan: RegionPlan,
+	workDir: string,
+	signal: AbortSignal,
+	onProgress: (percent: number) => void
+): Promise<string> {
+	const duration = region.duration
+	const dur = duration.toFixed(3)
+	const outputPath = path.join(workDir, `region-${String(index).padStart(3, '0')}.mp4`)
+
+	const command = ffmpeg()
+	const filters: string[] = []
+	let inputIdx = 0
+
+	// ---- Video: source slice, or black of exactly `duration` ----
+	if (region.video) {
+		const v = region.video
+		const cut = (v.out - v.in).toFixed(3)
+		command.input(v.srcPath).inputOptions(['-ss', v.in.toFixed(3), '-t', cut])
+		filters.push(`[${inputIdx++}:v]setpts=(PTS-STARTPTS)/${v.speed},${vnorm(plan.width, plan.height, plan.fps)}[v]`)
+	} else {
+		command.input(`color=black:size=${plan.width}x${plan.height}:rate=${plan.fps}`)
+			.inputFormat('lavfi').inputOptions(['-t', dur])
+		filters.push(`[${inputIdx++}:v]setsar=1,format=yuv420p[v]`)
+	}
+
+	// ---- Audio: silence, single stream, or amix of k streams ----
+	let audioLabel = '[a]'
+	if (region.audioSources.length === 0) {
+		command.input('anullsrc=r=48000:cl=stereo').inputFormat('lavfi').inputOptions(['-t', dur])
+		filters.push(`[${inputIdx++}:a]atrim=0:${dur},asetpts=PTS-STARTPTS[a]`)
+	} else {
+		const labels: string[] = []
+		region.audioSources.forEach((a, k) => {
+			const cut = (a.out - a.in).toFixed(3)
+			command.input(a.srcPath).inputOptions(['-ss', a.in.toFixed(3), '-t', cut])
+			const retime = a.speed === 1
+				? ''
+				: a.preservePitch ? `${atempoChain(a.speed)},` : `asetrate=48000*${a.speed},`
+			const gain = a.gain !== 1 ? `volume=${a.gain},` : ''
+			const label = `[a${k}]`
+			// apad + atrim pin every stream to EXACTLY the region duration so amix
+			// aligns them and the intermediate stays A/V frame-aligned for concat.
+			filters.push(
+				`[${inputIdx++}:a]asetpts=PTS-STARTPTS,${retime}${gain}aresample=48000,` +
+				`aformat=sample_fmts=fltp:channel_layouts=stereo,apad=whole_dur=${dur},atrim=0:${dur}${label}`
+			)
+			labels.push(label)
+		})
+		if (labels.length === 1) {
+			audioLabel = labels[0]
+		} else {
+			filters.push(`${labels.join('')}amix=inputs=${labels.length}:normalize=0[a]`)
+		}
+	}
+
+	command
+		.complexFilter(filters.join(';'))
+		.map('[v]')
+		.map(audioLabel)
+		.outputOptions([...intermediateOpts(), '-t', dur])
+
+	await runCommand(command, outputPath, signal, onProgress)
+	return outputPath
+}
+
+async function concatRegions(
+	regionFiles: string[],
+	workDir: string,
+	finalPath: string,
+	signal: AbortSignal,
+	reencode: boolean
+): Promise<void> {
+	const listPath = path.join(workDir, 'list.txt')
+	const list = regionFiles
+		.map((f) => `file '${path.basename(f).replace(/'/g, "'\\''")}'`)
+		.join('\n')
+	fs.writeFileSync(listPath, list)
+
+	const command = ffmpeg(listPath)
+		.inputOptions(['-f', 'concat', '-safe', '0'])
+		.outputOptions(
+			reencode
+				? [...intermediateOpts(), '-movflags', '+faststart']
+				: ['-c', 'copy', '-movflags', '+faststart']
+		)
+	await runCommand(command, finalPath, signal)
+}
+
+// ===== Orchestrator =====
+
+const activeRenders = new Map<string, { controller: AbortController; workDir: string | null }>()
+
+function emitRenderProgress(payload: EditorRenderProgress) {
+	BrowserWindow.getAllWindows().forEach((win) => {
+		win.webContents.send('editor-render-progress', payload)
+	})
+}
+
+export function abortEditorRender(renderId: string): void {
+	activeRenders.get(renderId)?.controller.abort()
+}
+
+export function abortRendersForThread(threadId: string): void {
+	// renderIds are opaque; abort everything registered under this thread by
+	// checking workDir containment (workdirs live under the thread's tempDir).
+	const thread = threadManager.getThread(threadId)
+	if (!thread) return
+	for (const [, entry] of activeRenders) {
+		if (entry.workDir && entry.workDir.startsWith(thread.tempDir)) {
+			entry.controller.abort()
+		}
+	}
+}
+
+export function startEditorRender(options: { threadId: string; quality: ExportQuality }): { renderId: string } {
+	const { threadId, quality } = options
+	const thread = threadManager.getThread(threadId)
+	if (!thread || thread.type !== 'editor' || !thread.editor) {
+		throw new Error('Not an editor project')
+	}
+	const doc = thread.editor
+
+	// ---- Pre-flight (synchronous — a bad timeline rejects the invoke
+	// immediately instead of producing a ghost render) ----
+	const plan = computeRegions(doc, quality)
+	const srcPaths = [...new Set(
+		plan.regions.flatMap((r) => [
+			...(r.video ? [r.video.srcPath] : []),
+			...r.audioSources.map((a) => a.srcPath)
+		])
+	)]
+	const missing = srcPaths.filter((p) => !fs.existsSync(p))
+	if (missing.length > 0) {
+		throw new Error(`Missing source file(s): ${missing.map((p) => path.basename(p)).join(', ')}`)
+	}
+
+	const renderId = uuidv4()
+	const exportsDir = path.join(thread.tempDir, THREAD_DIRS.EXPORTS)
+	const workDir = path.join(exportsDir, renderId)
+	fs.mkdirSync(workDir, { recursive: true })
+
+	const controller = new AbortController()
+	activeRenders.set(renderId, { controller, workDir })
+	const { signal } = controller
+
+	const progress = (percent: number, phase: EditorRenderProgress['phase']) =>
+		emitRenderProgress({ threadId, renderId, percent: Math.round(percent), phase })
+
+	// ---- Async render body ----
+	void (async () => {
+		const baseName = sanitizeFilename(thread.title || 'export')
+		let finalPath = path.join(exportsDir, `${baseName}_${renderId.slice(0, 8)}.mp4`)
+		try {
+			progress(0, 'rendering')
+
+			const videoTrack = doc.tracks
+				.filter((t) => t.kind === 'video' && !t.hidden)
+				.sort((a, b) => a.order - b.order)[0] || null
+			const items = videoTrack
+				? doc.timeline
+					.filter((i) => i.trackId === videoTrack.id)
+					.sort((a, b) => a.timelineStart - b.timelineStart)
+				: []
+			const audioTrackIds = new Set(
+				doc.tracks.filter((t) => t.kind === 'audio' && !t.hidden).map((t) => t.id)
+			)
+			const hasAudioItems = doc.timeline.some((i) => audioTrackIds.has(i.trackId))
+
+			if (videoTrack && isFastPathEligible(items, videoTrack, hasAudioItems)) {
+				// ---- Fast path: single-source trim+concat via assembleVideo ----
+				const asset = doc.media.find((a) => a.id === items[0].sourceAssetId)!
+				const srcPath = quality === 'preview'
+					? (asset.proxyPath || asset.originalPath)
+					: asset.originalPath
+				const segments: TimelineSegment[] = items.map((item, i) => ({
+					index: i + 1,
+					start: item.in.toFixed(3), // NEVER String(): exponent forms break timeToSeconds
+					end: item.out.toFixed(3),
+					text: '',
+					duration: item.out - item.in
+				}))
+				finalPath = await assembleVideo(
+					srcPath,
+					segments,
+					exportsDir,
+					renderId.slice(0, 8),
+					(percent) => progress(percent * 0.98, 'rendering'),
+					signal
+				)
+			} else {
+				// ---- Region path: segment-then-concat ----
+				const total = plan.regions.reduce((sum, r) => sum + r.duration, 0) || 1
+				let doneWeight = 0
+				let lastEmit = -1
+				const regionFiles: string[] = []
+
+				for (let i = 0; i < plan.regions.length; i++) {
+					if (signal.aborted) throw new Error('aborted')
+					const region = plan.regions[i]
+					const weight = region.duration / total
+					const onRegionProgress = (pct: number) => {
+						const overall = (doneWeight + weight * (pct / 100)) * 96
+						if (overall - lastEmit >= 1) {
+							lastEmit = overall
+							progress(overall, 'rendering')
+						}
+					}
+					const file = await renderRegion(region, i, plan, workDir, signal, onRegionProgress)
+					regionFiles.push(file)
+					doneWeight += weight
+					progress(doneWeight * 96, 'rendering')
+				}
+
+				progress(96, 'stitching')
+				try {
+					await concatRegions(regionFiles, workDir, finalPath, signal, false)
+				} catch (error) {
+					if (signal.aborted) throw error
+					console.warn('[render] copy-concat failed, retrying with re-encode:', error)
+					await concatRegions(regionFiles, workDir, finalPath, signal, true)
+				}
+			}
+
+			emitRenderProgress({ threadId, renderId, percent: 100, phase: 'done', outputPath: finalPath })
+		} catch (error: any) {
+			const message = signal.aborted ? 'aborted' : (error?.message || 'Export failed')
+			if (!signal.aborted) console.error('[render] Export failed:', error)
+			// Remove a partial final file
+			try { if (fs.existsSync(finalPath)) fs.unlinkSync(finalPath) } catch { /* ignore */ }
+			emitRenderProgress({ threadId, renderId, percent: 0, phase: 'error', error: message })
+		} finally {
+			try { fs.rmSync(workDir, { recursive: true, force: true }) } catch { /* ignore */ }
+			activeRenders.delete(renderId)
+		}
+	})()
+
+	return { renderId }
+}
diff --git a/src/main/editor/revisions.ts b/src/main/editor/revisions.ts
new file mode 100644
index 0000000..d6ed17a
--- /dev/null
+++ b/src/main/editor/revisions.ts
@@ -0,0 +1,94 @@
+import { app } from 'electron'
+import fs from 'fs'
+import path from 'path'
+import type { EditorRevision, EditorRevisionsFile } from '@shared/types'
+
+/**
+ * Revision-tree sidecar persistence (mirrors editor/history.ts).
+ * Revisions are coarse, permanent checkpoints holding FULL timeline
+ * snapshots — kept OUT of threads/{id}.json so the debounced doc autosave
+ * stays O(1), and OUT of the capped undo ring so they never dangle.
+ * The renderer owns the tree logic; this module only load/push/delete/persists.
+ */
+
+const MAX_REVISIONS = 100
+
+function revisionsDir(): string {
+	return path.join(app.getPath('userData'), 'editor-revisions')
+}
+
+function revisionsPath(threadId: string): string {
+	return path.join(revisionsDir(), `${threadId}.json`)
+}
+
+function emptyFile(threadId: string): EditorRevisionsFile {
+	return { threadId, schemaVersion: 1, revisionCounter: 0, revisions: [] }
+}
+
+function writeRevisions(file: EditorRevisionsFile) {
+	const dir = revisionsDir()
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+	const target = revisionsPath(file.threadId)
+	const temp = `${target}.tmp`
+	fs.writeFileSync(temp, JSON.stringify(file))
+	fs.renameSync(temp, target)
+}
+
+export function loadRevisions(threadId: string): EditorRevisionsFile {
+	const filePath = revisionsPath(threadId)
+	if (!fs.existsSync(filePath)) return emptyFile(threadId)
+	try {
+		const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as EditorRevisionsFile
+		if (!Array.isArray(parsed.revisions)) return emptyFile(threadId)
+		return { ...emptyFile(threadId), ...parsed, threadId }
+	} catch (error) {
+		console.error(`[editor-revisions] Failed to read revisions for ${threadId}:`, error)
+		return emptyFile(threadId)
+	}
+}
+
+/**
+ * Appends a revision: assigns a monotonic seq (max-ever — V numbers never
+ * reused after deletes) and enforces the cap by pruning the OLDEST LEAF
+ * (no children) that is neither the root nor the just-pushed revision.
+ * Leaf-only pruning guarantees no surviving revision loses an ancestor.
+ */
+export function pushRevision(threadId: string, revision: EditorRevision): { seq: number; count: number } {
+	const file = loadRevisions(threadId)
+	const seq = ++file.revisionCounter
+	const stored: EditorRevision = { ...revision, seq }
+	file.revisions.push(stored)
+
+	while (file.revisions.length > MAX_REVISIONS) {
+		const hasChildren = new Set(file.revisions.map((r) => r.parentId).filter(Boolean))
+		const candidate = file.revisions
+			.filter((r) => r.parentId !== null && r.id !== stored.id && !hasChildren.has(r.id))
+			.sort((a, b) => a.createdAt - b.createdAt)[0]
+		if (!candidate) break // pathological pure chain — allow exceeding the cap
+		file.revisions = file.revisions.filter((r) => r.id !== candidate.id)
+	}
+
+	writeRevisions(file)
+	return { seq, count: file.revisions.length }
+}
+
+/** Deletes the given ids (the renderer sends the fully collected subtree). */
+export function deleteRevisions(threadId: string, ids: string[]): boolean {
+	const file = loadRevisions(threadId)
+	const remove = new Set(ids)
+	// Never delete the root
+	const root = file.revisions.find((r) => r.parentId === null)
+	if (root) remove.delete(root.id)
+	file.revisions = file.revisions.filter((r) => !remove.has(r.id))
+	writeRevisions(file)
+	return true
+}
+
+export function deleteRevisionsFile(threadId: string): void {
+	const filePath = revisionsPath(threadId)
+	try {
+		if (fs.existsSync(filePath)) fs.unlinkSync(filePath)
+	} catch (error) {
+		console.error(`[editor-revisions] Failed to delete revisions for ${threadId}:`, error)
+	}
+}
diff --git a/src/main/ffmpeg/index.ts b/src/main/ffmpeg/index.ts
index 2e0fc12..71130ff 100644
--- a/src/main/ffmpeg/index.ts
+++ b/src/main/ffmpeg/index.ts
@@ -1,9 +1,10 @@
 import ffmpeg from 'fluent-ffmpeg'
 import ffmpegPath from 'ffmpeg-static'
 import ffprobePath from 'ffprobe-static'
+import fs from 'fs'
 import { join, basename, extname } from 'path'
 import process from 'node:process'
-import { TimelineSegment } from '../../shared/types'
+import { TimelineSegment, SilenceRegion } from '../../shared/types'
 
 const IS_MAC = process.platform === 'darwin'
 
@@ -130,6 +131,33 @@ export async function getVideoMetadata(filePath: string): Promise<import('../../
 	})
 }
 
+/**
+ * Metadata for an audio-only source (no video stream). Mirrors VideoMetadata's
+ * shape so a MediaAsset can carry it uniformly; width/height/fps are 0 since
+ * there is no picture, and the export normalization target ignores audio assets.
+ */
+export async function getAudioMetadata(filePath: string): Promise<import('../../shared/types').VideoMetadata> {
+	return new Promise((resolve, reject) => {
+		ffmpeg.ffprobe(filePath, (err, metadata) => {
+			if (err) return reject(err)
+			const audioStream = metadata.streams.find((s) => s.codec_type === 'audio')
+			if (!audioStream) {
+				return reject(new Error('No audio stream found'))
+			}
+			resolve({
+				duration: metadata.format.duration || 0,
+				width: 0,
+				height: 0,
+				size: metadata.format.size || 0,
+				codec: audioStream.codec_name || 'unknown',
+				fps: 0,
+				format: metadata.format.format_name || 'unknown',
+				hasAudio: true
+			})
+		})
+	})
+}
+
 /**
  * Returns true if the video resolution is 480p or lower.
  */
@@ -146,11 +174,16 @@ export async function isVideoLowResolution(filePath: string): Promise<boolean> {
 /**
  * Converts video to low resolution (480p).
  */
+// A proxy for scrubbing / thumbnails / scene detection never needs more than
+// this; halving a 60fps source roughly halves proxy encode time.
+const PROXY_MAX_FPS = 30
+
 export async function toLowResolution(
 	filePath: string,
 	outputDir: string,
 	onProgress?: (percent: number) => void,
-	signal?: AbortSignal
+	signal?: AbortSignal,
+	opts?: { sourceFps?: number }
 ): Promise<string> {
 	const ext = extname(filePath).toLowerCase()
 	const rawFilename = basename(filePath, extname(filePath))
@@ -161,12 +194,23 @@ export async function toLowResolution(
 		throw new Error('FFmpeg downscaling aborted by user before start')
 	}
 
-	return new Promise((resolve, reject) => {
-		const isWebm = ext === '.webm'
+	const isWebm = ext === '.webm'
+
+	// Cap fps only when the source is above the ceiling — applying fps=30 to a
+	// <=30fps source would DUPLICATE frames (slower + larger), not drop any.
+	const capFps = !!opts?.sourceFps && opts.sourceFps > PROXY_MAX_FPS
+	const vf = capFps ? `fps=${PROXY_MAX_FPS},scale=-2:480` : 'scale=-2:480'
 
+	// Hardware-accelerated DECODE (Mac) is a clear win for decode-bound proxies
+	// (~-25%). But when we're already dropping frames via the fps filter,
+	// benchmarks show the per-frame GPU→CPU download makes it slower than plain
+	// software decode — so only use hw decode when NOT capping fps.
+	const preferHwDecode = IS_MAC && !isWebm && !capFps
 
+	const encode = (hwDecode: boolean): Promise<string> => new Promise((resolve, reject) => {
 		const command = ffmpeg(filePath)
-			.outputOptions(['-vf', 'scale=-2:480'])
+		if (hwDecode) command.inputOptions(['-hwaccel', 'videotoolbox'])
+		command.outputOptions(['-vf', vf])
 
 		if (isWebm) {
 			// WebM (VP8/VP9) optimizations
@@ -179,8 +223,7 @@ export async function toLowResolution(
 				'-b:v', '1M'
 			])
 		} else if (IS_MAC) {
-			// Mac hardware acceleration
-
+			// Mac hardware encode
 			command.outputOptions([
 				'-c:v', 'h264_videotoolbox',
 				'-b:v', '2M',
@@ -199,10 +242,7 @@ export async function toLowResolution(
 		}
 
 		if (signal) {
-			signal.addEventListener('abort', () => {
-				console.log('FFmpeg toLowResolution aborted by signal')
-				command.kill('SIGKILL')
-			})
+			signal.addEventListener('abort', () => command.kill('SIGKILL'))
 		}
 
 		command
@@ -223,6 +263,18 @@ export async function toLowResolution(
 			})
 			.run()
 	})
+
+	try {
+		return await encode(preferHwDecode)
+	} catch (err) {
+		// Hardware decode can reject some inputs — fall back to software decode
+		// once rather than failing the whole proxy step.
+		if (!signal?.aborted && preferHwDecode) {
+			console.warn('[ffmpeg] hw-decode proxy failed, retrying with software decode:', (err as Error).message)
+			return await encode(false)
+		}
+		throw err
+	}
 }
 
 /**
@@ -468,3 +520,126 @@ export async function extractFrame(
 		command.run()
 	})
 }
+
+/**
+ * Batched filmstrip extractor (PRD §5.5). ONE ffmpeg pass samples a frame
+ * every `intervalSec` seconds (`fps=1/interval`) at 120px height — unlike
+ * extractFrame's process-per-frame, a multi-hour source stays a single
+ * bounded run. Returns entries mapping each frame to its source time.
+ */
+export async function generateFilmstrip(
+	videoPath: string,
+	outputDir: string,
+	intervalSec: number,
+	signal?: AbortSignal,
+	onProgress?: (percent: number) => void
+): Promise<{ time: number; thumbnailPath: string }[]> {
+	if (signal?.aborted) {
+		throw new Error('Filmstrip generation aborted before start')
+	}
+
+	const pattern = join(outputDir, 'strip_%05d.jpg')
+
+	await new Promise<void>((resolve, reject) => {
+		const command = ffmpeg(videoPath)
+			.outputOptions([
+				'-vf', `fps=1/${intervalSec},scale=-2:120`,
+				'-q:v', '5'
+			])
+			.output(pattern)
+			.on('progress', (progress) => {
+				if (onProgress && progress.percent) {
+					onProgress(Math.round(progress.percent))
+				}
+			})
+			.on('end', () => resolve())
+			.on('error', (err) => {
+				if (signal?.aborted) {
+					return reject(new Error('Filmstrip generation aborted by user'))
+				}
+				console.error('Error generating filmstrip:', err)
+				reject(err)
+			})
+
+		if (signal) {
+			signal.addEventListener('abort', () => command.kill('SIGKILL'))
+		}
+
+		command.run()
+	})
+
+	return fs.readdirSync(outputDir)
+		.filter((f) => /^strip_\d+\.jpg$/.test(f))
+		.sort()
+		.map((f, i) => ({
+			// fps=1/N emits the frame representing window [iN, (i+1)N) — stamp it
+			// at the window centre so nearest-entry lookup lands inside the window.
+			time: (i + 0.5) * intervalSec,
+			thumbnailPath: join(outputDir, f)
+		}))
+}
+
+/**
+ * Assistive silence/dead-air finder (PRD §5.6). Runs ffmpeg's `silencedetect`
+ * audio filter over the source and parses the `silence_start`/`silence_end`
+ * markers off stderr into source-time regions. Read-only analysis — it never
+ * mutates media; the caller reviews the ranges before applying any cut.
+ *
+ * Requires an audio stream — guard with `metadata.hasAudio` before calling.
+ */
+export async function detectSilence(
+	videoPath: string,
+	opts?: { noiseDb?: number; minDurationSec?: number },
+	signal?: AbortSignal,
+	onProgress?: (percent: number) => void
+): Promise<SilenceRegion[]> {
+	const noiseDb = opts?.noiseDb ?? -30
+	const minDurationSec = opts?.minDurationSec ?? 0.5
+
+	if (signal?.aborted) {
+		throw new Error('Silence detection aborted before start')
+	}
+
+	return new Promise((resolve, reject) => {
+		const regions: SilenceRegion[] = []
+		let pendingStart: number | null = null
+
+		const command = ffmpeg(videoPath)
+			.audioFilters(`silencedetect=noise=${noiseDb}dB:d=${minDurationSec}`)
+			.outputOptions(['-f', 'null'])
+			.output(process.platform === 'win32' ? 'NUL' : '/dev/null')
+			.on('progress', (progress) => {
+				if (onProgress && progress.percent) {
+					onProgress(Math.round(progress.percent))
+				}
+			})
+			.on('stderr', (line: string) => {
+				const startMatch = line.match(/silence_start:\s*(-?[\d.]+)/)
+				if (startMatch) {
+					pendingStart = parseFloat(startMatch[1])
+					return
+				}
+				const endMatch = line.match(/silence_end:\s*(-?[\d.]+)/)
+				if (endMatch) {
+					const end = parseFloat(endMatch[1])
+					const start = Math.max(0, pendingStart ?? 0)
+					if (Number.isFinite(end) && end > start) regions.push({ start, end })
+					pendingStart = null
+				}
+			})
+			.on('end', () => resolve(regions))
+			.on('error', (err) => {
+				if (signal?.aborted) {
+					return reject(new Error('Silence detection aborted by user'))
+				}
+				console.error('Error during silence detection:', err)
+				reject(err)
+			})
+
+		if (signal) {
+			signal.addEventListener('abort', () => command.kill('SIGKILL'))
+		}
+
+		command.run()
+	})
+}
diff --git a/src/main/index.ts b/src/main/index.ts
index 9659da5..31fe4a1 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -18,10 +18,18 @@ import * as imageGeneration from './pipeline/phases/image-generation'
 import { backgroundTaskManager } from './tasks'
 import { GeminiAdapter } from './gemini/adapter'
 
-import { checkFFmpegAvailability, getVideoMetadata } from './ffmpeg'
+import { checkFFmpegAvailability, getVideoMetadata, detectSilence } from './ffmpeg'
 import { checkScenedetectAvailability } from './scenedetect'
 import { checkYtDlpAvailability, downloadVideo, getVideoFormats } from './ytdlp'
 import { dependencyManager } from './dependencies/manager'
+import * as editorAssets from './editor/assets'
+import * as editorPreprocess from './editor/preprocess'
+import * as editorHistory from './editor/history'
+import * as editorPrompt from './editor/prompt'
+import * as editorRender from './editor/render'
+import * as editorRevisions from './editor/revisions'
+import { BUILTIN_PERSONAS } from './constants/personas'
+import { v4 as uuidv4 } from 'uuid'
 import { THREAD_DIRS } from './constants/paths'
 import { GEMINI_MODEL_2_5_FLASH, MODEL_METADATA } from './constants/gemini'
 import { electronApp, optimizer, is } from '@electron-toolkit/utils'
@@ -111,7 +119,11 @@ app.whenReady().then(() => {
 	ipcMain.handle('select-video', async () => {
 		const result = await dialog.showOpenDialog({
 			properties: ['openFile'],
-			filters: [{ name: 'Videos', extensions: ['mp4', 'avi', 'mov', 'webm'] }]
+			filters: [
+				{ name: 'Media', extensions: ['mp4', 'avi', 'mov', 'webm', 'mp3', 'wav', 'm4a', 'aac', 'flac', 'ogg', 'opus', 'wma'] },
+				{ name: 'Videos', extensions: ['mp4', 'avi', 'mov', 'webm'] },
+				{ name: 'Audio', extensions: ['mp3', 'wav', 'm4a', 'aac', 'flac', 'ogg', 'opus', 'wma'] }
+			]
 		})
 
 		if (result.canceled || result.filePaths.length === 0) {
@@ -329,6 +341,16 @@ app.whenReady().then(() => {
 		return MODEL_METADATA
 	})
 
+	// Editor personas: built-ins (code) merged with the user's global library
+	ipcMain.handle('get-personas', () => {
+		return [...BUILTIN_PERSONAS, ...settingsManager.getPersonas()]
+	})
+
+	ipcMain.handle('set-personas', (_event, personas: any[]) => {
+		const saved = settingsManager.setPersonas(personas)
+		return [...BUILTIN_PERSONAS, ...saved]
+	})
+
 	// Thread Management
 	ipcMain.handle('create-thread', async (_event, { videoPath, videoName, imagePaths }) => {
 		const newThread = await threadManager.createThread(videoPath, videoName, imagePaths)
@@ -345,6 +367,270 @@ app.whenReady().then(() => {
 		return true
 	})
 
+	// ===== Timeline Video Editor =====
+
+	// Creates an editor project thread. Deliberately does NOT auto-start
+	// preprocessing (media is imported per-asset inside the editor).
+	ipcMain.handle('create-editor-project', async (_event, { title }: { title?: string }) => {
+		return await threadManager.createEditorThread(title || 'Untitled Project')
+	})
+
+	ipcMain.handle('rename-editor-project', async (_event, { threadId, title }: {
+		threadId: string, title: string
+	}) => {
+		const clean = (title || '').trim().slice(0, 120)
+		if (!clean) return null
+		return await threadManager.updateThread(threadId, { title: clean })
+	})
+
+	// Autosave of RENDERER-OWNED editor fields only. Main owns preprocessing-derived
+	// asset state (preprocessing/proxyPath/metadata/preprocessState/clips content);
+	// the renderer owns selection, clip-selected flags, tracks, timeline, meta, personas.
+	// This ownership split is what prevents autosave/thread-updated echo clobbering.
+	ipcMain.handle('save-editor-doc', async (_event, { threadId, patch }: {
+		threadId: string
+		patch: {
+			tracks?: any[]
+			timeline?: any[]
+			timelineMeta?: any
+			selection?: any
+			activePersonaId?: string
+			customPersonas?: any[]
+			clipSelections?: Record<string, boolean>
+			historyRef?: any
+			markers?: any[]
+			currentRevisionId?: string
+		}
+	}) => {
+		return await threadManager.updateThreadWith(threadId, (thread) => {
+			if (thread.type !== 'editor' || !thread.editor) return null
+
+			const editor = { ...thread.editor }
+			if (patch.tracks) editor.tracks = patch.tracks
+			if (patch.timeline) editor.timeline = patch.timeline
+			if (patch.timelineMeta) editor.timelineMeta = patch.timelineMeta
+			if (patch.selection) editor.selection = patch.selection
+			if (patch.activePersonaId !== undefined) editor.activePersonaId = patch.activePersonaId
+			if (patch.customPersonas) editor.customPersonas = patch.customPersonas
+			// historyRef travels WITH the doc so the undo pointer and the timeline
+			// state land in one atomic write (crash-consistent by construction).
+			if (patch.historyRef) editor.historyRef = patch.historyRef
+			if (patch.markers) editor.markers = patch.markers
+			if (patch.currentRevisionId !== undefined) editor.currentRevisionId = patch.currentRevisionId
+
+			// Fold clip-selected flags into the matching clips (the one renderer-owned
+			// field living inside main-owned MediaAsset records).
+			if (patch.clipSelections) {
+				editor.media = editor.media.map(asset => ({
+					...asset,
+					clips: asset.clips.map(clip =>
+						patch.clipSelections![clip.id] !== undefined
+							? { ...clip, selected: patch.clipSelections![clip.id] }
+							: clip
+					)
+				}))
+			}
+
+			return { editor }
+		})
+	})
+
+	// Import a local file as a MediaAsset and start per-asset preprocessing.
+	ipcMain.handle('add-media-asset', async (_event, { threadId, filePath, name }: {
+		threadId: string, filePath: string, name?: string
+	}) => {
+		const asset = await editorAssets.createMediaAsset(threadId, { sourcePath: filePath, name, referenceInPlace: true })
+		if (asset && asset.preprocessState !== 'error') {
+			// Fire-and-forget: progress streams via background-task-update
+			editorPreprocess.preprocessMediaAsset(threadId, asset.id).catch((error) => {
+				console.error(`[editor] preprocess failed for ${asset.id}:`, error)
+			})
+		}
+		return asset
+	})
+
+	// Import from URL/YouTube: download straight into the asset's source dir,
+	// with per-asset progress (the legacy 'download-progress' event is keyless
+	// and breaks under concurrent imports).
+	ipcMain.handle('import-media-url', async (event, { threadId, url, resolution }: {
+		threadId: string, url: string, resolution?: string
+	}) => {
+		const thread = threadManager.getThread(threadId)
+		if (!thread || thread.type !== 'editor') throw new Error('Not an editor project')
+
+		const assetId = uuidv4()
+		const sourceDir = join(thread.tempDir, 'media', assetId, 'source')
+		fs.mkdirSync(sourceDir, { recursive: true })
+
+		try {
+			const result = await downloadVideo(url, sourceDir, resolution, (percent) => {
+				event.sender.send('editor-import-progress', { threadId, assetId, url, percent })
+			})
+
+			const asset = await editorAssets.createMediaAsset(threadId, {
+				sourcePath: result.path,
+				name: result.name,
+				assetId
+			})
+			if (asset && asset.preprocessState !== 'error') {
+				editorPreprocess.preprocessMediaAsset(threadId, asset.id).catch((error) => {
+					console.error(`[editor] preprocess failed for ${asset.id}:`, error)
+				})
+			}
+			return asset
+		} catch (error) {
+			// Failed import: remove the partial asset dir so nothing dangles
+			try {
+				fs.rmSync(join(thread.tempDir, 'media', assetId), { recursive: true, force: true })
+			} catch { /* best effort */ }
+			throw error
+		}
+	})
+
+	ipcMain.handle('remove-media-asset', async (_event, { threadId, assetId }: {
+		threadId: string, assetId: string
+	}) => {
+		return await editorAssets.removeAsset(threadId, assetId)
+	})
+
+	// Retry / re-run / opt-in steps (e.g. ['descriptions']) for one asset.
+	ipcMain.handle('preprocess-media', async (_event, { threadId, assetId, steps, threshold }: {
+		threadId: string, assetId: string, steps?: string[], threshold?: number
+	}) => {
+		editorPreprocess.preprocessMediaAsset(threadId, assetId, {
+			steps: steps as any,
+			threshold
+		}).catch((error) => {
+			console.error(`[editor] preprocess retry failed for ${assetId}:`, error)
+		})
+		return true
+	})
+
+	// Remove derived Gemini data (transcript / scene descriptions) from an asset.
+	ipcMain.handle('clear-asset-data', (_event, { threadId, assetId, kind }: {
+		threadId: string, assetId: string, kind: 'transcript' | 'descriptions'
+	}) => {
+		return editorAssets.clearAssetData(threadId, assetId, kind)
+	})
+
+	// Scene-piece corrections (§5.2): merge adjacent pieces / split further.
+	ipcMain.handle('merge-clips', (_event, { threadId, assetId, clipIds }: {
+		threadId: string, assetId: string, clipIds: string[]
+	}) => {
+		return editorAssets.mergeClips(threadId, assetId, clipIds)
+	})
+
+	ipcMain.handle('split-clip', (_event, { threadId, assetId, clipId, atSec }: {
+		threadId: string, assetId: string, clipId: string, atSec?: number
+	}) => {
+		return editorAssets.splitClip(threadId, assetId, clipId, atSec)
+	})
+
+	// Assistive silence/dead-air finder (§5.6). Read-only analysis over the
+	// asset's proxy/original — returns candidate source-time ranges the user
+	// reviews before applying as ripple-deletes. Never mutates media.
+	ipcMain.handle('find-silence', async (event, { threadId, assetId, noiseDb, minDurationSec }: {
+		threadId: string, assetId: string, noiseDb?: number, minDurationSec?: number
+	}) => {
+		const asset = threadManager.getThread(threadId)?.editor?.media.find((a) => a.id === assetId)
+		if (!asset) throw new Error('Asset not found')
+		if (asset.metadata && asset.metadata.hasAudio === false) return []
+		const source = asset.proxyPath || asset.originalPath
+		let lastPercent = -1
+		return await detectSilence(source, { noiseDb, minDurationSec }, undefined, (percent) => {
+			if (percent - lastPercent < 2 && percent !== 100) return
+			lastPercent = percent
+			if (!event.sender.isDestroyed()) {
+				event.sender.send('editor-silence-progress', { assetId, percent })
+			}
+		})
+	})
+
+	// AI prompt turns (M3): one structured call per turn, streamed via
+	// editor-turn-update; the base doc is never mutated until user accept.
+	ipcMain.handle('run-editor-prompt', (_event, options: {
+		threadId: string, personaId: string, prompt: string, baseStepId: string,
+		selectedItemIds: string[], playheadSec: number, widen?: 'chapter' | 'full'
+	}) => {
+		return editorPrompt.runEditorPrompt(options)
+	})
+
+	ipcMain.handle('abort-editor-prompt', (_event, { turnId }: { threadId: string, turnId: string }) => {
+		editorPrompt.abortEditorPrompt(turnId)
+		return true
+	})
+
+	// Renderer stamps the applied history step / revision back onto the turn.
+	ipcMain.handle('update-editor-turn', async (_event, { threadId, turnId, patch }: {
+		threadId: string, turnId: string, patch: { resultStepId?: string, revisionId?: string }
+	}) => {
+		return await threadManager.updateThreadWith(threadId, (thread) => {
+			if (!thread.editor) return null
+			const turns = thread.editor.turns.map((t) =>
+				t.id === turnId
+					? {
+						...t,
+						resultStepId: patch.resultStepId ?? t.resultStepId,
+						revisionId: patch.revisionId ?? t.revisionId
+					}
+					: t
+			)
+			return { editor: { ...thread.editor, turns } }
+		})
+	})
+
+	// Export / render (M4): fast path via assembleVideo, region path via
+	// segment-then-concat; progress streams over editor-render-progress.
+	ipcMain.handle('export-editor-timeline', (_event, { threadId, quality }: {
+		threadId: string, quality: 'original' | 'preview'
+	}) => {
+		return editorRender.startEditorRender({ threadId, quality })
+	})
+
+	ipcMain.handle('abort-editor-render', (_event, { renderId }: { renderId: string }) => {
+		editorRender.abortEditorRender(renderId)
+		return true
+	})
+
+	// Undo/redo history sidecar (renderer-authoritative; main persists)
+	ipcMain.handle('get-editor-history', (_event, threadId: string) => {
+		return editorHistory.loadHistory(threadId)
+	})
+
+	ipcMain.handle('push-editor-step', async (_event, { threadId, step, keyframe }: {
+		threadId: string, step: any, keyframe?: any
+	}) => {
+		return await editorHistory.pushStep(threadId, step, keyframe)
+	})
+
+	ipcMain.handle('set-editor-history-pointer', (_event, { threadId, currentStepId }: {
+		threadId: string, currentStepId: string
+	}) => {
+		return editorHistory.setPointer(threadId, currentStepId)
+	})
+
+	ipcMain.handle('clear-editor-history', (_event, { threadId }: { threadId: string }) => {
+		editorHistory.clearHistory(threadId)
+		return true
+	})
+
+	// Revision tree sidecar (renderer owns tree logic; main persists)
+	ipcMain.handle('get-editor-revisions', (_event, threadId: string) => {
+		return editorRevisions.loadRevisions(threadId)
+	})
+
+	ipcMain.handle('push-editor-revision', (_event, { threadId, revision }: {
+		threadId: string, revision: any
+	}) => {
+		return editorRevisions.pushRevision(threadId, revision)
+	})
+
+	ipcMain.handle('delete-editor-revisions', (_event, { threadId, ids }: {
+		threadId: string, ids: string[]
+	}) => {
+		return editorRevisions.deleteRevisions(threadId, ids)
+	})
+
 	ipcMain.handle('get-all-threads', () => {
 		return threadManager.getAllThreads()
 	})
@@ -354,6 +640,17 @@ app.whenReady().then(() => {
 	})
 
 	ipcMain.handle('delete-thread', (_event, id) => {
+		// Editor threads: abort any live per-asset preprocessing and renders,
+		// and remove the history sidecar before deletion
+		const thread = threadManager.getThread(id)
+		if (thread?.type === 'editor' && thread.editor) {
+			for (const asset of thread.editor.media) {
+				editorPreprocess.abortAssetPreprocessing(id, asset.id)
+			}
+			editorRender.abortRendersForThread(id)
+			editorHistory.deleteHistory(id)
+			editorRevisions.deleteRevisionsFile(id)
+		}
 		return threadManager.deleteThread(id)
 	})
 
diff --git a/src/main/scenedetect/index.ts b/src/main/scenedetect/index.ts
index 107a15a..b5e18e0 100644
--- a/src/main/scenedetect/index.ts
+++ b/src/main/scenedetect/index.ts
@@ -173,11 +173,16 @@ export class SceneDetector {
      * @returns Array of detected scenes sorted by start time.
      * @throws If the CLI exits non-zero, the CSV is missing, or values cannot be parsed.
      */
-    async detectScenes(videoPath: string, signal?: AbortSignal): Promise<Scene[]> {
+    async detectScenes(
+        videoPath: string,
+        signal?: AbortSignal,
+        threshold: number = CONTENT_THRESHOLD,
+        onProgress?: (percent: number) => void
+    ): Promise<Scene[]> {
         const tempDir = await fs.mkdtemp(join(tmpdir(), 'scenedetect-'))
 
         try {
-            await this.runScenedetect(videoPath, tempDir, signal)
+            await this.runScenedetect(videoPath, tempDir, signal, threshold, onProgress)
             const csvPath = await this.locateCsvFile(tempDir, videoPath)
             const csvContent = await fs.readFile(csvPath, 'utf-8')
             return this.parseCsv(csvContent)
@@ -194,14 +199,20 @@ export class SceneDetector {
     /**
      * Execute the scenedetect CLI process.
      */
-    private async runScenedetect(videoPath: string, outputDir: string, signal?: AbortSignal): Promise<void> {
+    private async runScenedetect(
+        videoPath: string,
+        outputDir: string,
+        signal?: AbortSignal,
+        threshold: number = CONTENT_THRESHOLD,
+        onProgress?: (percent: number) => void
+    ): Promise<void> {
         const pathOrRef = await resolveScenedetectPath()
-        
+
         return new Promise((resolve, reject) => {
             const scenedetectArgs = [
                 '-i', videoPath,
                 'detect-content',
-                '-t', String(CONTENT_THRESHOLD),
+                '-t', String(threshold),
                 'list-scenes',
                 '-o', outputDir,
                 '-f', CSV_FILENAME,
@@ -219,6 +230,17 @@ export class SceneDetector {
                 args = scenedetectArgs
             }
 
+            const parseProgress = (chunk: Buffer | string) => {
+                // scenedetect's tqdm writes "Detected: N | Progress:  45%|…" to
+                // stderr even without a tty — surface the last percent per chunk.
+                if (!onProgress) return
+                const matches = String(chunk).match(/Progress:\s*(\d{1,3})%/g)
+                if (matches?.length) {
+                    const last = matches[matches.length - 1].match(/(\d{1,3})/)
+                    if (last) onProgress(Number(last[1]))
+                }
+            }
+
             const child = execFile(cmd, args, (error, _stdout, stderr) => {
                 if (error) {
                     if (signal?.aborted) {
@@ -235,6 +257,8 @@ export class SceneDetector {
                 resolve()
             })
 
+            child.stderr?.on('data', parseProgress)
+
             if (signal) {
                 signal.addEventListener('abort', () => {
                     console.log('scenedetect process killed by signal')
diff --git a/src/main/settings.ts b/src/main/settings.ts
index 45621ba..f652e9a 100644
--- a/src/main/settings.ts
+++ b/src/main/settings.ts
@@ -2,13 +2,16 @@ import { app } from 'electron'
 import { join } from 'path'
 import { existsSync, mkdirSync, readFileSync, writeFileSync, realpathSync } from 'fs'
 import os from 'os'
-import { ModelSettings } from '../shared/types'
+import { EditorPersona, ModelSettings } from '../shared/types'
 import { DEFAULT_MODEL_SETTINGS } from './constants/gemini'
+import { BUILTIN_PERSONAS } from './constants/personas'
 
 interface Settings {
 	tempDir: string
 	geminiApiKey?: string
 	modelSettings?: ModelSettings
+	/** User-defined editor personas ONLY — built-ins are merged at read time. */
+	personas?: EditorPersona[]
 }
 
 class SettingsManager {
@@ -52,7 +55,8 @@ class SettingsManager {
 				return {
 					tempDir: parsed.tempDir || this.defaultTempDir,
 					geminiApiKey: parsed.geminiApiKey,
-					modelSettings: this.mergeModelSettings(parsed.modelSettings || DEFAULT_MODEL_SETTINGS)
+					modelSettings: this.mergeModelSettings(parsed.modelSettings || DEFAULT_MODEL_SETTINGS),
+					personas: Array.isArray(parsed.personas) ? parsed.personas : []
 				}
 			}
 		} catch (error) {
@@ -151,6 +155,24 @@ class SettingsManager {
 		this.saveSettings()
 		return DEFAULT_MODEL_SETTINGS
 	}
+
+	/** User-defined personas only (built-ins live in constants/personas.ts). */
+	getPersonas(): EditorPersona[] {
+		return this.settings.personas || []
+	}
+
+	/**
+	 * Persists user personas. Built-in entries and any entry whose id collides
+	 * with a built-in are filtered out — built-ins are code, not data.
+	 */
+	setPersonas(personas: EditorPersona[]): EditorPersona[] {
+		const builtinIds = new Set(BUILTIN_PERSONAS.map((p) => p.id))
+		this.settings.personas = (personas || []).filter(
+			(p) => !p.builtin && !builtinIds.has(p.id)
+		)
+		this.saveSettings()
+		return this.settings.personas
+	}
 }
 
 export const settingsManager = new SettingsManager()
diff --git a/src/main/threads/index.ts b/src/main/threads/index.ts
index 5889779..03f5129 100644
--- a/src/main/threads/index.ts
+++ b/src/main/threads/index.ts
@@ -3,7 +3,7 @@ import fs from 'fs'
 import path from 'path'
 import { v4 as uuidv4 } from 'uuid'
 import { MessageRole, FileType } from '@shared/types'
-import type { Message, Thread, Usage, UsageRecord, VideoMetadata } from '@shared/types'
+import type { EditorDocument, Message, Thread, Track, Usage, UsageRecord, VideoMetadata } from '@shared/types'
 import { settingsManager } from '../settings'
 import { getVideoMetadata } from '../ffmpeg'
 import { THREAD_DIRS } from '../constants/paths'
@@ -137,6 +137,58 @@ class ThreadManager {
 		return thread
 	}
 
+	// Create a new timeline-editor project thread.
+	// Unlike createThread, no videoPath is required and NO preprocessing auto-starts —
+	// media is imported per-asset inside the editor (see src/main/editor/).
+	async createEditorThread(title: string): Promise<Thread> {
+		const id = uuidv4()
+		const tempDir = settingsManager.getThreadTempDir(id)
+
+		const seedTrack = (kind: Track['kind'], name: string, order: number): Track => ({
+			id: uuidv4(),
+			kind,
+			name,
+			order,
+			muted: false,
+			locked: false,
+			hidden: false,
+			height: 64
+		})
+
+		const editor: EditorDocument = {
+			schemaVersion: 1,
+			media: [],
+			tracks: [
+				seedTrack('video', 'V1', 0),
+				seedTrack('audio', 'A1', 1),
+				seedTrack('overlay', 'OV', 2)
+			],
+			timeline: [],
+			timelineMeta: { fps: 30, width: 1920, height: 1080, duration: 0 },
+			activePersonaId: '',
+			turns: [],
+			historyRef: { currentStepId: '', stepCount: 0 },
+			selection: {}
+		}
+
+		const thread: Thread = {
+			id,
+			title,
+			type: 'editor',
+			preprocessing: {},
+			tempDir,
+			messages: [],
+			versionCounter: 0,
+			usageHistory: [],
+			editor,
+			createdAt: Date.now(),
+			updatedAt: Date.now()
+		}
+
+		this.saveThread(thread)
+		return thread
+	}
+
 
 	// Helper to normalize paths (handles symlinks like /var vs /private/var on macOS)
 	private normalize(p: string | undefined): string | undefined {
@@ -209,6 +261,30 @@ class ThreadManager {
 					return msg
 				})
 
+				// Update editor document media paths (timeline editor threads)
+				if (thread.editor?.media) {
+					for (const asset of thread.editor.media) {
+						asset.originalPath = fixPath(asset.originalPath) || asset.originalPath
+						asset.proxyPath = fixPath(asset.proxyPath)
+						if (asset.preprocessing) {
+							for (const key of Object.keys(asset.preprocessing) as Array<keyof Thread['preprocessing']>) {
+								const value = asset.preprocessing[key]
+								if (typeof value === 'string') {
+									(asset.preprocessing as any)[key] = fixPath(value)
+								} else if (Array.isArray(value)) {
+									(asset.preprocessing as any)[key] = value.map(fixPath)
+								}
+							}
+						}
+						for (const clip of asset.clips || []) {
+							clip.thumbnailPath = fixPath(clip.thumbnailPath)
+						}
+						for (const entry of asset.filmstrip || []) {
+							entry.thumbnailPath = fixPath(entry.thumbnailPath) || entry.thumbnailPath
+						}
+					}
+				}
+
 				// Save the repaired thread back to metadata and mirror it
 				this.saveThread(thread)
 			}
@@ -320,14 +396,20 @@ class ThreadManager {
 		}
 	}
 
-	// Update a thread atomically
-	updateThread(id: string, updates: Partial<Thread>): Promise<Thread | null> {
+	// Update a thread atomically via a mutator that runs INSIDE the queued closure.
+	// The mutator receives the freshest thread state and returns the partial update
+	// (or null to skip). This makes concurrent read-modify-write patterns safe
+	// (e.g. multiple assets patching thread.editor.media in parallel).
+	updateThreadWith(id: string, mutator: (thread: Thread) => Partial<Thread> | null): Promise<Thread | null> {
 		const existingQueue = this.updateQueues.get(id) || Promise.resolve()
 
 		const nextUpdate = existingQueue.then(async () => {
 			const thread = this.getThread(id)
 			if (!thread) return null
 
+			const updates = mutator(thread)
+			if (!updates) return thread
+
 			const updatedThread = {
 				...thread,
 				...updates,
@@ -359,6 +441,11 @@ class ThreadManager {
 		return nextUpdate
 	}
 
+	// Update a thread atomically with a precomputed partial.
+	updateThread(id: string, updates: Partial<Thread>): Promise<Thread | null> {
+		return this.updateThreadWith(id, () => updates)
+	}
+
 	private deleteFile(filePath: string) {
 		if (!filePath) return
 		const cleanPath = filePath.replace('file://', '')
diff --git a/src/preload/index.ts b/src/preload/index.ts
index f96f709..89865c8 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -48,6 +48,72 @@ const api = {
 	getModelSettings: () => ipcRenderer.invoke('get-model-settings'),
 	setModelSettings: (settings: any) => ipcRenderer.invoke('set-model-settings', settings),
 	resetModelSettings: () => ipcRenderer.invoke('reset-model-settings'),
+	// Timeline Video Editor
+	createEditorProject: (title?: string) => ipcRenderer.invoke('create-editor-project', { title }),
+	renameEditorProject: (data: { threadId: string, title: string }) =>
+		ipcRenderer.invoke('rename-editor-project', data),
+	saveEditorDoc: (data: { threadId: string, patch: any }) =>
+		ipcRenderer.invoke('save-editor-doc', data),
+	addMediaAsset: (data: { threadId: string, filePath: string, name?: string }) =>
+		ipcRenderer.invoke('add-media-asset', data),
+	importMediaUrl: (data: { threadId: string, url: string, resolution?: string }) =>
+		ipcRenderer.invoke('import-media-url', data),
+	removeMediaAsset: (data: { threadId: string, assetId: string }) =>
+		ipcRenderer.invoke('remove-media-asset', data),
+	preprocessMedia: (data: { threadId: string, assetId: string, steps?: string[], threshold?: number }) =>
+		ipcRenderer.invoke('preprocess-media', data),
+	findSilence: (data: { threadId: string, assetId: string, noiseDb?: number, minDurationSec?: number }) =>
+		ipcRenderer.invoke('find-silence', data),
+	clearAssetData: (data: { threadId: string, assetId: string, kind: 'transcript' | 'descriptions' }) =>
+		ipcRenderer.invoke('clear-asset-data', data),
+	mergeClips: (data: { threadId: string, assetId: string, clipIds: string[] }) =>
+		ipcRenderer.invoke('merge-clips', data),
+	splitClip: (data: { threadId: string, assetId: string, clipId: string, atSec?: number }) =>
+		ipcRenderer.invoke('split-clip', data),
+	onEditorImportProgress: (callback: (data: { threadId: string, assetId: string, url?: string, percent: number }) => void) => {
+		const listener = (_event: any, data: any) => callback(data)
+		ipcRenderer.on('editor-import-progress', listener)
+		return () => ipcRenderer.removeListener('editor-import-progress', listener)
+	},
+	onEditorSilenceProgress: (callback: (data: { assetId: string, percent: number }) => void) => {
+		const listener = (_event: any, data: any) => callback(data)
+		ipcRenderer.on('editor-silence-progress', listener)
+		return () => ipcRenderer.removeListener('editor-silence-progress', listener)
+	},
+	getPersonas: () => ipcRenderer.invoke('get-personas'),
+	setPersonas: (personas: any[]) => ipcRenderer.invoke('set-personas', personas),
+	exportEditorTimeline: (data: { threadId: string, quality: 'original' | 'preview' }) =>
+		ipcRenderer.invoke('export-editor-timeline', data),
+	abortEditorRender: (data: { renderId: string }) =>
+		ipcRenderer.invoke('abort-editor-render', data),
+	onEditorRenderProgress: (callback: (data: any) => void) => {
+		const listener = (_event: any, data: any) => callback(data)
+		ipcRenderer.on('editor-render-progress', listener)
+		return () => ipcRenderer.removeListener('editor-render-progress', listener)
+	},
+	runEditorPrompt: (data: { threadId: string, personaId: string, prompt: string, baseStepId: string, selectedItemIds: string[], playheadSec: number, widen?: string }) =>
+		ipcRenderer.invoke('run-editor-prompt', data),
+	abortEditorPrompt: (data: { threadId: string, turnId: string }) =>
+		ipcRenderer.invoke('abort-editor-prompt', data),
+	updateEditorTurn: (data: { threadId: string, turnId: string, patch: { resultStepId?: string, revisionId?: string } }) =>
+		ipcRenderer.invoke('update-editor-turn', data),
+	onEditorTurnUpdate: (callback: (data: any) => void) => {
+		const listener = (_event: any, data: any) => callback(data)
+		ipcRenderer.on('editor-turn-update', listener)
+		return () => ipcRenderer.removeListener('editor-turn-update', listener)
+	},
+	getEditorHistory: (threadId: string) => ipcRenderer.invoke('get-editor-history', threadId),
+	pushEditorStep: (data: { threadId: string, step: any, keyframe?: any }) =>
+		ipcRenderer.invoke('push-editor-step', data),
+	setEditorHistoryPointer: (data: { threadId: string, currentStepId: string }) =>
+		ipcRenderer.invoke('set-editor-history-pointer', data),
+	clearEditorHistory: (data: { threadId: string }) =>
+		ipcRenderer.invoke('clear-editor-history', data),
+	getEditorRevisions: (threadId: string) => ipcRenderer.invoke('get-editor-revisions', threadId),
+	pushEditorRevision: (data: { threadId: string, revision: any }) =>
+		ipcRenderer.invoke('push-editor-revision', data),
+	deleteEditorRevisions: (data: { threadId: string, ids: string[] }) =>
+		ipcRenderer.invoke('delete-editor-revisions', data),
 	// Thread Management
 	createThread: (data: { videoPath?: string, videoName: string, imagePaths?: string[] }) =>
 		ipcRenderer.invoke('create-thread', data),
diff --git a/src/renderer/src/assets/main.css b/src/renderer/src/assets/main.css
index 798b0da..a66fc44 100644
--- a/src/renderer/src/assets/main.css
+++ b/src/renderer/src/assets/main.css
@@ -64,3 +64,38 @@
     @apply h-full min-h-[50vh] !resize-none;
   }
 }
+
+/* Reduced motion (PRD §5.11): suppress decorative animation — fades, pulses,
+   spinners' easing flair, hover lifts, press-scales, and smooth scrolling.
+   Functional motion (video playback, the moving playhead, progress bars'
+   width changes) is untouched: none of it is driven by CSS animation. */
+@media (prefers-reduced-motion: reduce) {
+  html {
+    /* !important: a bundled third-party sheet re-declares this after us */
+    scroll-behavior: auto !important;
+  }
+
+  .animate-fade-in-up,
+  .animate-menu,
+  .animate-pulse-soft,
+  .animate-indeterminate {
+    animation: none !important;
+  }
+
+  /* Keep spinners visible (they convey "busy") but slow their spin. */
+  .animate-spin {
+    animation-duration: 2.5s !important;
+  }
+
+  /* Neutralize transition-driven decoration: hover lifts and press scales. */
+  *,
+  ::before,
+  ::after {
+    transition-duration: 0.01ms !important;
+  }
+  .active\:scale-95:active,
+  .hover\:scale-125:hover,
+  [class*="hover:-translate-y"]:hover {
+    transform: none !important;
+  }
+}
diff --git a/src/renderer/src/components/graph/GraphHeader.vue b/src/renderer/src/components/graph/GraphHeader.vue
index db682cc..3bc2621 100644
--- a/src/renderer/src/components/graph/GraphHeader.vue
+++ b/src/renderer/src/components/graph/GraphHeader.vue
@@ -11,7 +11,19 @@
         </button>
       </SlimTooltip>
 
-      <h1
+      <!-- Editable title (editor projects) — click to rename in place -->
+      <input v-if="editable && renaming" ref="titleInput" v-model="draft"
+        class="text-xl font-bold font-heading text-zinc-900 dark:text-zinc-100 tracking-tight min-w-[200px] max-w-[40%] ml-2 bg-transparent border-b border-primary/50 outline-none"
+        @keydown.enter.prevent="commitRename" @keydown.esc.prevent="cancelRename" @blur="commitRename" />
+      <button v-else-if="editable"
+        class="group/title flex items-center gap-1.5 min-w-0 max-w-[40%] ml-2"
+        title="Rename project" @click="startRename">
+        <span class="text-xl font-bold font-heading text-zinc-900 dark:text-zinc-100 truncate tracking-tight">
+          {{ title || 'Untitled Project' }}
+        </span>
+        <span class="iconify tabler--pencil w-3.5 h-3.5 text-zinc-400 opacity-0 group-hover/title:opacity-100 transition shrink-0"></span>
+      </button>
+      <h1 v-else
         class="text-xl font-bold font-heading text-zinc-900 dark:text-zinc-100 truncate tracking-tight min-w-[200px] max-w-[40%] ml-2">
         {{ title || 'Graph Task Manager' }}
       </h1>
@@ -48,13 +60,40 @@
 </template>
 
 <script setup lang="ts">
+import { nextTick, ref } from 'vue'
 import SlimTooltip from '../SlimTooltip.vue'
-defineProps<{
+
+const props = defineProps<{
   title?: string
   totalCost: number
+  editable?: boolean
 }>()
 
-defineEmits<{
+const emit = defineEmits<{
   (e: 'back'): void
+  (e: 'rename', value: string): void
 }>()
+
+const renaming = ref(false)
+const draft = ref('')
+const titleInput = ref<HTMLInputElement | null>(null)
+
+const startRename = async () => {
+  draft.value = props.title || ''
+  renaming.value = true
+  await nextTick()
+  titleInput.value?.focus()
+  titleInput.value?.select()
+}
+
+const commitRename = () => {
+  if (!renaming.value) return // guard: blur fires after esc/enter already closed it
+  renaming.value = false
+  const next = draft.value.trim()
+  if (next && next !== props.title) emit('rename', next)
+}
+
+const cancelRename = () => {
+  renaming.value = false
+}
 </script>
diff --git a/src/renderer/src/editor/VideoEditorPage.vue b/src/renderer/src/editor/VideoEditorPage.vue
new file mode 100644
index 0000000..6d57f7a
--- /dev/null
+++ b/src/renderer/src/editor/VideoEditorPage.vue
@@ -0,0 +1,207 @@
+<template>
+	<div class="h-full w-full flex flex-col relative bg-zinc-50 dark:bg-zinc-950 overflow-hidden">
+		<!-- Ambient Backgrounds -->
+		<div
+			class="absolute top-[-10%] left-[-10%] w-[60%] h-[60%] bg-primary/10 dark:bg-primary/5 rounded-full blur-[140px] pointer-events-none transition-all duration-1000 animate-pulse-soft">
+		</div>
+		<div
+			class="absolute bottom-[-10%] right-[-10%] w-[60%] h-[60%] bg-secondary/10 dark:bg-secondary/5 rounded-full blur-[140px] pointer-events-none transition-all duration-1000 animate-pulse-soft">
+		</div>
+
+		<GraphHeader :title="editorStore.thread?.title || 'Untitled Project'" :total-cost="totalCost" editable
+			@back="router.push('/home')" @rename="editorStore.renameProject($event)" />
+
+		<!-- Export lives in the app's fixed top-right cluster so it composes
+		     with the settings/theme buttons instead of colliding with them -->
+		<Teleport to="#header-actions-portal">
+			<button v-if="!editorStore.loading && !notFound"
+				class="px-3 py-1.5 rounded-xl text-xs font-bold transition active:scale-95 flex items-center gap-1.5"
+				:class="editorStore.isRendering
+					? 'bg-primary/10 text-primary ring-1 ring-primary/30'
+					: editorStore.canExport
+						? 'bg-primary text-white shadow-md shadow-primary/20 hover:bg-primary-dark'
+						: 'bg-zinc-100 dark:bg-zinc-800 text-zinc-400 cursor-not-allowed'"
+				:disabled="!editorStore.canExport && !editorStore.isRendering"
+				:title="editorStore.canExport || editorStore.isRendering ? 'Export the timeline' : 'Add clips to the timeline first'"
+				@click="showExport = true">
+				<span class="iconify tabler--file-export w-3.5 h-3.5"></span>
+				{{ editorStore.isRendering ? `Exporting ${editorStore.renderState?.percent ?? 0}%` : 'Export' }}
+			</button>
+		</Teleport>
+
+		<!-- Loading -->
+		<div v-if="editorStore.loading" class="flex-1 flex items-center justify-center z-10">
+			<div class="animate-spin rounded-lg h-10 w-10 border-4 border-primary border-t-transparent"></div>
+		</div>
+
+		<!-- Not found -->
+		<div v-else-if="notFound" class="flex-1 flex flex-col items-center justify-center gap-4 z-10">
+			<p class="text-zinc-500 dark:text-zinc-400 font-medium">This editor project could not be loaded.</p>
+			<button
+				class="px-4 py-2 rounded-xl bg-primary text-white text-sm font-bold shadow-md shadow-primary/20 hover:bg-primary-dark transition active:scale-95"
+				@click="router.push('/home')">
+				Back to Home
+			</button>
+		</div>
+
+		<!-- Editor workspace -->
+		<template v-else>
+			<main class="flex-1 min-h-0 flex flex-col z-10 p-3 gap-3">
+				<!-- Top zones: media | preview | right rail — rails collapse to slim strips -->
+				<div class="flex-1 min-h-0 grid gap-3 transition-all duration-300"
+					:style="{ gridTemplateColumns: `${leftOpen ? '280px' : '36px'} minmax(0,1fr) auto` }">
+
+					<!-- Left rail: media -->
+					<MediaPanel v-if="leftOpen" v-model:collapsed="leftCollapsedProxy" />
+					<CollapsedRail v-else side="left" label="Media" icon="tabler--photo-video"
+						@open="leftOpen = true" />
+
+					<!-- Center: the monitor gets the full column now -->
+					<PreviewMonitor class="min-h-0" />
+
+					<!-- Right region: two independently-collapsible COLUMNS —
+					     [Chat | Revisions] and [Inspector]. Closing a column frees
+					     its horizontal space so the player widens. -->
+					<div class="flex min-h-0 gap-3">
+						<!-- Column 1: Chat / Revisions -->
+						<div v-if="chatColOpen" class="w-[300px] flex flex-col min-h-0 gap-1.5">
+							<div class="flex items-center gap-0.5 px-1 shrink-0">
+								<button v-for="tab in (['chat', 'revisions'] as const)" :key="tab"
+									class="px-2 py-1 rounded-lg text-[9px] font-bold uppercase tracking-widest transition relative"
+									:class="chatTab === tab
+										? 'text-primary bg-primary/10'
+										: 'text-zinc-400 hover:text-zinc-600 dark:hover:text-zinc-300'"
+									@click="selectChatTab(tab)">
+									{{ tab }}
+									<span v-if="tab === 'revisions' && revisionsBadge"
+										class="absolute top-0.5 right-0.5 w-1.5 h-1.5 rounded-full bg-secondary animate-pulse-soft"></span>
+								</button>
+								<button title="Collapse panel"
+									class="ml-auto w-7 h-7 flex items-center justify-center rounded-lg text-zinc-400 hover:text-primary hover:bg-primary/10 transition active:scale-95 shrink-0"
+									@click="chatColOpen = false">
+									<span class="iconify tabler--layout-sidebar-right-collapse w-4 h-4"></span>
+								</button>
+							</div>
+							<ChatPanel v-show="chatTab === 'chat'" class="flex-1 min-h-0" />
+							<RevisionsPanel v-if="chatTab === 'revisions'" class="flex-1 min-h-0" />
+						</div>
+						<CollapsedRail v-else side="right" label="Chat" icon="tabler--message-circle"
+							:badge="chatBadge || revisionsBadge" @open="chatColOpen = true" />
+
+						<!-- Column 2: Inspector -->
+						<div v-if="inspectorOpen" class="w-[280px] flex flex-col min-h-0 gap-1.5">
+							<div class="flex items-center gap-1 px-1 shrink-0">
+								<span class="text-[9px] font-bold uppercase tracking-widest text-primary bg-primary/10 px-2 py-1 rounded-lg">inspect</span>
+								<button title="Collapse panel"
+									class="ml-auto w-7 h-7 flex items-center justify-center rounded-lg text-zinc-400 hover:text-primary hover:bg-primary/10 transition active:scale-95 shrink-0"
+									@click="inspectorOpen = false">
+									<span class="iconify tabler--layout-sidebar-right-collapse w-4 h-4"></span>
+								</button>
+							</div>
+							<InspectorPanel class="flex-1 min-h-0" />
+						</div>
+						<CollapsedRail v-else side="right" label="Inspector" icon="tabler--adjustments"
+							@open="inspectorOpen = true" />
+					</div>
+				</div>
+
+				<!-- Bottom zone: timeline -->
+				<TimelinePanel class="h-52 shrink-0" />
+			</main>
+
+			<ExportDialog v-model="showExport" />
+		</template>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, h, onMounted, ref, watch } from 'vue'
+import type { FunctionalComponent } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+import GraphHeader from '../components/graph/GraphHeader.vue'
+import { useEditorStore } from '../stores/editorStore'
+import RevisionsPanel from './components/RevisionsPanel.vue'
+import MediaPanel from './components/MediaPanel.vue'
+import PreviewMonitor from './components/PreviewMonitor.vue'
+import InspectorPanel from './components/InspectorPanel.vue'
+import TimelinePanel from './components/TimelinePanel.vue'
+import ChatPanel from './components/ChatPanel.vue'
+import ExportDialog from './components/ExportDialog.vue'
+
+const route = useRoute()
+const router = useRouter()
+const editorStore = useEditorStore()
+
+const notFound = ref(false)
+const showExport = ref(false)
+
+// ===== Collapsible rails (persisted per machine) =====
+const leftOpen = ref(localStorage.getItem('editor.leftRail') !== 'closed')
+// Right region = two independently-collapsible COLUMNS. Closing a column frees
+// its horizontal space, widening the player.
+const chatColOpen = ref(localStorage.getItem('editor.chatCol') !== 'closed')
+const inspectorOpen = ref(localStorage.getItem('editor.inspectorCol') !== 'closed')
+watch(leftOpen, (v) => localStorage.setItem('editor.leftRail', v ? 'open' : 'closed'))
+watch(chatColOpen, (v) => localStorage.setItem('editor.chatCol', v ? 'open' : 'closed'))
+watch(inspectorOpen, (v) => localStorage.setItem('editor.inspectorCol', v ? 'open' : 'closed'))
+// MediaPanel exposes its own collapse control through this proxy
+const leftCollapsedProxy = computed({ get: () => !leftOpen.value, set: (v) => { leftOpen.value = !v } })
+
+/** Slim vertical strip shown in place of a collapsed rail. */
+const CollapsedRail: FunctionalComponent<
+	{ side: 'left' | 'right'; label: string; icon: string; badge?: boolean },
+	{ open: () => void }
+> = (props, { emit }) =>
+	h('button', {
+		class: 'glass-card rounded-2xl flex flex-col items-center gap-2 py-3 px-0 text-zinc-400 hover:text-primary transition group relative',
+		title: `Open ${props.label}`,
+		onClick: () => emit('open')
+	}, [
+		h('span', { class: `iconify ${props.side === 'left' ? 'tabler--layout-sidebar-left-expand' : 'tabler--layout-sidebar-right-expand'} w-4 h-4 group-hover:scale-110 transition-transform` }),
+		h('span', { class: `iconify ${props.icon} w-3.5 h-3.5 opacity-60` }),
+		h('span', {
+			class: 'text-[9px] font-bold uppercase tracking-widest [writing-mode:vertical-rl] mt-1'
+		}, props.label),
+		props.badge
+			? h('span', { class: 'absolute top-2 right-1.5 w-1.5 h-1.5 rounded-full bg-accent animate-pulse-soft' })
+			: null
+	])
+CollapsedRail.props = ['side', 'label', 'icon', 'badge']
+CollapsedRail.emits = ['open']
+
+// ===== Right rail =====
+// Row 1 toggles Chat | Revisions; Row 2 is the Inspector.
+const chatTab = ref<'chat' | 'revisions'>('chat')
+const revisionsBadge = ref(false)
+const chatBadge = ref(false)
+
+const selectChatTab = (tab: 'chat' | 'revisions') => {
+	chatTab.value = tab
+	if (tab === 'revisions') revisionsBadge.value = false
+}
+
+watch(() => editorStore.lastResult, (result) => {
+	if (result && chatTab.value !== 'revisions') revisionsBadge.value = true
+})
+
+// Badge Chat/Revisions when a turn completes while that column is closed.
+watch(() => editorStore.doc?.turns?.length ?? 0, (n, old) => {
+	if (n > (old ?? 0) && !chatColOpen.value) chatBadge.value = true
+})
+watch(chatColOpen, (open) => { if (open) chatBadge.value = false })
+
+// Selecting a clip reveals the Inspector row so its details are visible.
+watch(() => editorStore.selectedItemIds.length, (n) => {
+	if (n > 0 && !inspectorOpen.value) inspectorOpen.value = true
+})
+
+const totalCost = computed(() =>
+	(editorStore.thread?.usageHistory || []).reduce((sum, record) => sum + (record.cost || 0), 0)
+)
+
+onMounted(async () => {
+	const id = route.params.id as string
+	const ok = await editorStore.loadProject(id)
+	if (!ok) notFound.value = true
+})
+</script>
diff --git a/src/renderer/src/editor/components/AiResultCard.vue b/src/renderer/src/editor/components/AiResultCard.vue
new file mode 100644
index 0000000..876b31f
--- /dev/null
+++ b/src/renderer/src/editor/components/AiResultCard.vue
@@ -0,0 +1,98 @@
+<template>
+	<div v-if="result"
+		class="rounded-xl bg-primary/5 dark:bg-primary/10 p-3 animate-fade-in-up">
+		<!-- Header -->
+		<div class="flex items-center justify-between gap-3 mb-2">
+			<div class="flex items-center gap-2 min-w-0">
+				<span class="text-base leading-none">{{ persona?.icon || '✨' }}</span>
+				<span class="text-xs font-bold text-zinc-800 dark:text-zinc-200 font-heading">Applied</span>
+				<span class="text-[10px] font-bold text-primary font-mono">V{{ result.revisionSeq }}</span>
+				<span v-if="result.scopeLabel"
+					class="text-[9px] font-bold uppercase tracking-widest text-zinc-400 truncate">{{ result.scopeLabel }}</span>
+			</div>
+			<div class="flex items-center gap-1.5 shrink-0">
+				<span v-if="result.counts.added" class="px-1.5 py-0.5 rounded bg-primary/10 text-primary text-[9px] font-bold font-mono">+{{ result.counts.added }}</span>
+				<span v-if="result.counts.removed" class="px-1.5 py-0.5 rounded bg-red-500/10 text-red-500 text-[9px] font-bold font-mono">−{{ result.counts.removed }}</span>
+				<span v-if="result.counts.updated" class="px-1.5 py-0.5 rounded bg-secondary/10 text-secondary text-[9px] font-bold font-mono">{{ result.counts.updated }} changed</span>
+				<span v-if="result.counts.markers" class="px-1.5 py-0.5 rounded bg-accent/10 text-accent text-[9px] font-bold font-mono">{{ result.counts.markers }} markers</span>
+				<button class="w-5 h-5 flex items-center justify-center rounded text-zinc-400 hover:text-zinc-600 dark:hover:text-zinc-300"
+					title="Dismiss" @click="store.dismissResult()">
+					<span class="iconify tabler--x w-3 h-3"></span>
+				</button>
+			</div>
+		</div>
+
+		<!-- Rationale -->
+		<p v-if="result.rationale" class="text-xs text-zinc-600 dark:text-zinc-300 leading-relaxed">
+			{{ result.rationale }}
+		</p>
+
+		<!-- Notices -->
+		<div v-if="result.droppedOps.length"
+			class="mt-2 px-2.5 py-1.5 rounded-lg bg-amber-500/10 border border-amber-500/20">
+			<p class="text-[10px] font-medium text-amber-600 dark:text-amber-400 leading-snug">
+				<span class="iconify tabler--alert-triangle w-3 h-3 inline-block align-[-1px] mr-1"></span>
+				{{ result.droppedOps.length }} proposed change{{ result.droppedOps.length === 1 ? '' : 's' }} could not be
+				applied (the timeline had changed).
+			</p>
+		</div>
+		<div v-if="result.thinContext"
+			class="mt-2 px-2.5 py-1.5 rounded-lg bg-zinc-500/5 border border-zinc-500/10 flex items-center justify-between gap-2">
+			<p class="text-[10px] font-medium text-zinc-500 leading-snug">
+				<span class="iconify tabler--info-circle w-3 h-3 inline-block align-[-1px] mr-1"></span>
+				Context is thin — scene descriptions would improve results.
+			</p>
+			<button v-if="store.selectedAsset"
+				class="px-2 py-1 rounded-lg bg-secondary/10 text-secondary text-[9px] font-bold uppercase tracking-widest hover:bg-secondary/20 transition shrink-0"
+				@click="store.describeAsset(store.selectedAsset.id)">
+				Describe scenes
+			</button>
+		</div>
+		<p v-if="result.truncated" class="mt-2 text-[10px] text-zinc-400 leading-snug">
+			<span class="iconify tabler--info-circle w-3 h-3 inline-block align-[-1px] mr-1"></span>
+			Long project — the AI saw a summarized view of out-of-scope material.
+		</p>
+
+		<!-- Footer -->
+		<div class="mt-3 flex items-center justify-between gap-3">
+			<span v-if="turn?.usage" class="text-[9px] font-mono text-zinc-400">
+				~{{ turn.usage.totalTokens.toLocaleString() }} tok · ${{ (turn.cost || 0).toFixed(4) }}
+			</span>
+			<button v-if="parentRevision"
+				class="ml-auto px-3 py-1.5 rounded-xl border border-zinc-200 dark:border-zinc-700 text-xs font-bold text-zinc-600 dark:text-zinc-300 hover:border-primary/40 hover:text-primary transition active:scale-95"
+				:title="'Switch back to the previous revision — this result stays in the tree'"
+				@click="goBack">
+				<span class="iconify tabler--arrow-back-up w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+				Back to V{{ parentRevision.seq }}
+			</button>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+
+const store = useEditorStore()
+
+const result = computed(() => store.lastResult)
+
+const turn = computed(() =>
+	store.doc?.turns.find((t) => t.id === result.value?.turnId) || null
+)
+
+const persona = computed(() => {
+	const id = turn.value?.personaId
+	return store.personas.find((p) => p.id === id) || store.activePersona
+})
+
+const parentRevision = computed(() =>
+	store.revisions.find((r) => r.id === result.value?.parentRevisionId) || null
+)
+
+const goBack = async () => {
+	if (!result.value?.parentRevisionId) return
+	const ok = await store.switchRevision(result.value.parentRevisionId)
+	if (ok) store.dismissResult()
+}
+</script>
diff --git a/src/renderer/src/editor/components/AssetRow.vue b/src/renderer/src/editor/components/AssetRow.vue
new file mode 100644
index 0000000..96c033a
--- /dev/null
+++ b/src/renderer/src/editor/components/AssetRow.vue
@@ -0,0 +1,166 @@
+<template>
+	<div class="mb-1.5 p-3 rounded-xl transition cursor-pointer group"
+		:class="active
+			? 'bg-primary/5 dark:bg-primary/10 ring-1 ring-primary/30'
+			: 'hover:bg-zinc-100/70 dark:hover:bg-zinc-900/50'"
+		:draggable="canPlace"
+		:title="canPlace ? 'Drag onto the timeline to place the whole file' : undefined"
+		@click="$emit('select')"
+		@dragstart="onDragStart">
+		<div class="flex items-start gap-3">
+			<!-- Thumbnail -->
+			<div
+				class="w-16 h-10 rounded-lg bg-zinc-200 dark:bg-zinc-800 overflow-hidden shrink-0 flex items-center justify-center">
+				<img v-if="thumbSrc" :src="thumbSrc" class="w-full h-full object-cover" loading="lazy" />
+				<span v-else class="iconify w-4 h-4 text-zinc-400"
+					:class="asset.kind === 'audio' ? 'tabler--music' : 'tabler--movie'"></span>
+			</div>
+
+			<div class="flex-1 min-w-0">
+				<p class="text-xs font-bold text-zinc-800 dark:text-zinc-200 truncate">{{ asset.name }}</p>
+				<div class="flex items-center gap-2 mt-0.5">
+					<span v-if="asset.metadata" class="text-[10px] font-mono text-zinc-500">
+						{{ formatDuration(asset.metadata.duration) }}
+					</span>
+					<span v-if="asset.metadata?.hasAudio"
+						class="iconify tabler--volume w-3 h-3 text-zinc-400" title="Has audio"></span>
+					<!-- State chip -->
+					<span class="text-[9px] font-bold uppercase tracking-widest px-1.5 py-0.5 rounded"
+						:class="stateChipClass">
+						{{ stateLabel }}
+					</span>
+				</div>
+			</div>
+
+			<!-- Remove -->
+			<button
+				class="w-6 h-6 flex items-center justify-center rounded-lg text-zinc-400 opacity-0 group-hover:opacity-100 hover:text-red-500 hover:bg-red-500/10 transition shrink-0"
+				title="Remove media"
+				@click.stop="editorStore.removeAsset(asset.id)">
+				<span class="iconify tabler--trash w-3.5 h-3.5"></span>
+			</button>
+		</div>
+
+		<!-- Per-step progress bars while running -->
+		<div v-if="asset.preprocessState === 'running' && !interrupted" class="mt-2 space-y-1.5">
+			<div v-for="task in runningTasks" :key="task.id" class="flex items-center gap-2">
+				<span class="text-[9px] font-bold uppercase tracking-widest w-20 shrink-0 truncate"
+					:class="task.state === 'pending' ? 'text-zinc-300 dark:text-zinc-600' : 'text-zinc-400'">
+					{{ stepName(task) }}
+				</span>
+				<div class="flex-1 h-1 rounded-full bg-zinc-200 dark:bg-zinc-800 overflow-hidden relative">
+					<!-- Indeterminate shimmer: running with no measurable percent (e.g. scene detection) -->
+					<div v-if="task.state === 'running' && task.progress === undefined"
+						class="absolute inset-0 rounded-full bg-gradient-to-r from-transparent via-primary/70 to-transparent animate-indeterminate">
+					</div>
+					<div v-else class="h-full rounded-full transition-all duration-300"
+						:class="task.state === 'error' ? 'bg-red-500' : task.state === 'completed' ? 'bg-accent' : 'bg-primary'"
+						:style="{ width: `${task.state === 'completed' ? 100 : task.progress ?? 0}%` }"></div>
+				</div>
+			</div>
+		</div>
+
+		<!-- Interrupted (app quit mid-run) -->
+		<div v-if="interrupted" class="mt-2 flex items-center justify-between gap-2">
+			<p class="text-[11px] text-amber-600 dark:text-amber-400 font-medium">Processing was interrupted.</p>
+			<button
+				class="px-2 py-1 rounded-lg bg-amber-500/10 text-amber-600 dark:text-amber-400 text-[10px] font-bold uppercase tracking-widest hover:bg-amber-500/20 transition"
+				@click.stop="editorStore.retryAsset(asset.id)">
+				Resume
+			</button>
+		</div>
+
+		<!-- Error state -->
+		<div v-if="asset.preprocessState === 'error'" class="mt-2">
+			<p class="text-[11px] text-red-500 font-medium leading-snug line-clamp-2">
+				{{ asset.preprocessError || 'Preprocessing failed.' }}
+			</p>
+			<div class="mt-1.5 flex items-center gap-2">
+				<button
+					class="px-2 py-1 rounded-lg bg-red-500/10 text-red-500 text-[10px] font-bold uppercase tracking-widest hover:bg-red-500/20 transition"
+					@click.stop="editorStore.retryAsset(asset.id)">
+					Retry
+				</button>
+				<button v-if="isScenedetectMissing"
+					class="px-2 py-1 rounded-lg bg-amber-500/10 text-amber-600 dark:text-amber-400 text-[10px] font-bold uppercase tracking-widest hover:bg-amber-500/20 transition"
+					@click.stop="installScenedetect">
+					Install scene detection
+				</button>
+			</div>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { BackgroundTask, MediaAsset } from '@shared/types'
+import { useEditorStore } from '../../stores/editorStore'
+
+const props = defineProps<{
+	asset: MediaAsset
+	active: boolean
+}>()
+
+defineEmits<{ (e: 'select'): void }>()
+
+const editorStore = useEditorStore()
+
+const interrupted = computed(() => editorStore.interruptedAssets.has(props.asset.id))
+
+const runningTasks = computed<BackgroundTask[]>(() => editorStore.assetTasks(props.asset.id))
+
+const thumbSrc = computed(() => {
+	const thumb = props.asset.clips.find((c) => c.thumbnailPath)?.thumbnailPath
+	return thumb ? `media://${thumb}` : null
+})
+
+const isScenedetectMissing = computed(() =>
+	(props.asset.preprocessError || '').includes('scenedetect-missing') || !editorStore.deps.scenedetect
+)
+
+// Only a probed asset with a real duration can be dropped as a whole-file item.
+const canPlace = computed(() => (props.asset.metadata?.duration || 0) > 0)
+
+const onDragStart = (event: DragEvent) => {
+	if (!event.dataTransfer || !canPlace.value) return
+	event.dataTransfer.setData('application/x-frameflow-asset', props.asset.id)
+	event.dataTransfer.setData(`application/x-frameflow-kind-${props.asset.kind === 'audio' ? 'audio' : 'video'}`, '1')
+	event.dataTransfer.effectAllowed = 'copy'
+}
+
+const stateLabel = computed(() => {
+	if (interrupted.value) return 'paused'
+	switch (props.asset.preprocessState) {
+		case 'running': return 'processing'
+		case 'completed': return `${props.asset.clips.length} pieces`
+		case 'error': return 'error'
+		default: return 'pending'
+	}
+})
+
+const stateChipClass = computed(() => {
+	if (interrupted.value) return 'bg-amber-500/10 text-amber-600 dark:text-amber-400'
+	switch (props.asset.preprocessState) {
+		case 'running': return 'bg-primary/10 text-primary'
+		case 'completed': return 'bg-accent/10 text-accent'
+		case 'error': return 'bg-red-500/10 text-red-500'
+		default: return 'bg-zinc-500/10 text-zinc-500'
+	}
+})
+
+const stepName = (task: BackgroundTask) => task.id.split(':')[1] || task.name
+
+const formatDuration = (seconds: number) => {
+	const m = Math.floor(seconds / 60)
+	const s = Math.floor(seconds % 60)
+	return `${m}:${String(s).padStart(2, '0')}`
+}
+
+const installScenedetect = async () => {
+	try {
+		await (window as any).api.installDependency('scenedetect')
+	} catch (error) {
+		console.error('Failed to start scenedetect install:', error)
+	}
+}
+</script>
diff --git a/src/renderer/src/editor/components/ChatPanel.vue b/src/renderer/src/editor/components/ChatPanel.vue
new file mode 100644
index 0000000..6de4a5b
--- /dev/null
+++ b/src/renderer/src/editor/components/ChatPanel.vue
@@ -0,0 +1,156 @@
+<template>
+	<div class="glass-card rounded-2xl flex flex-col min-h-0 overflow-hidden">
+		<!-- Turn history -->
+		<div ref="scrollRef" class="flex-1 min-h-0 overflow-y-auto custom-scrollbar px-3 py-3 space-y-3">
+			<!-- Empty state — reflects whether media is ready to talk about -->
+			<div v-if="turns.length === 0" class="h-full flex flex-col items-center justify-center gap-2 text-center px-4">
+				<span class="text-2xl" :class="{ 'opacity-40': !store.hasReadyMedia }">{{ store.activePersona?.icon || '🎬' }}</span>
+				<template v-if="store.hasReadyMedia">
+					<p class="text-xs font-bold text-zinc-600 dark:text-zinc-300">
+						{{ store.activePersona?.name || 'Your editor' }} is ready
+					</p>
+					<p class="text-[11px] text-zinc-400 leading-relaxed">
+						Ask for a cut, a cleanup, or a question about the footage. Every request and result stays here.
+					</p>
+				</template>
+				<template v-else-if="store.mediaProcessing">
+					<p class="text-xs font-bold text-zinc-600 dark:text-zinc-300 flex items-center gap-1.5">
+						<span class="w-3 h-3 rounded-full border-2 border-primary border-t-transparent animate-spin"></span>
+						Preparing your media…
+					</p>
+					<p class="text-[11px] text-zinc-400 leading-relaxed">
+						Chat unlocks once the footage is broken into pieces you can edit.
+					</p>
+				</template>
+				<template v-else>
+					<p class="text-xs font-bold text-zinc-600 dark:text-zinc-300">Import media to start</p>
+					<p class="text-[11px] text-zinc-400 leading-relaxed">
+						Add a video in the Media panel. Once it’s processed, your editor persona can build the cut.
+					</p>
+				</template>
+			</div>
+
+			<template v-for="turn in turns" :key="turn.id">
+				<!-- User prompt -->
+				<div class="flex flex-col items-end gap-1">
+					<div class="max-w-[85%] px-3 py-2 rounded-2xl rounded-br-md bg-primary text-white text-xs leading-relaxed whitespace-pre-wrap">
+						{{ turn.prompt }}
+					</div>
+					<span class="text-[9px] font-bold uppercase tracking-widest text-zinc-400 flex items-center gap-1">
+						<span v-if="turn.scopeLabel" class="text-secondary">{{ turn.scopeLabel }}</span>
+						<span>{{ formatTime(turn.createdAt) }}</span>
+					</span>
+				</div>
+
+				<!-- Assistant response -->
+				<div class="flex items-start gap-2">
+					<span class="text-sm leading-none mt-1 shrink-0">{{ personaIcon(turn.personaId) }}</span>
+					<div class="flex-1 min-w-0">
+						<!-- Running -->
+						<div v-if="turn.status === 'pending' || turn.status === 'running'"
+							class="px-3 py-2 rounded-2xl rounded-tl-md bg-zinc-100 dark:bg-zinc-900 inline-flex items-center gap-2">
+							<div class="w-3 h-3 rounded-full border-2 border-primary border-t-transparent animate-spin"></div>
+							<span class="text-[11px] text-zinc-500">Working on it…</span>
+						</div>
+
+						<!-- Error -->
+						<div v-else-if="turn.status === 'error'"
+							class="px-3 py-2 rounded-2xl rounded-tl-md bg-red-500/10 border border-red-500/20">
+							<p class="text-[11px] text-red-500 leading-snug">{{ turn.error || 'The request failed.' }}</p>
+							<button class="mt-1.5 px-2 py-0.5 rounded-lg bg-red-500/10 text-red-500 text-[9px] font-bold uppercase tracking-widest hover:bg-red-500/20 transition"
+								@click="store.runPrompt(turn.prompt)">
+								Retry
+							</button>
+						</div>
+
+						<!-- Question answer -->
+						<div v-else-if="turn.answer"
+							class="px-3 py-2 rounded-2xl rounded-tl-md bg-zinc-100 dark:bg-zinc-900 text-xs text-zinc-700 dark:text-zinc-300 leading-relaxed whitespace-pre-wrap">
+							{{ turn.answer }}
+						</div>
+
+						<!-- Applied edit -->
+						<div v-else class="px-3 py-2 rounded-2xl rounded-tl-md bg-zinc-100 dark:bg-zinc-900 space-y-1.5">
+							<p v-if="turn.rationale" class="text-[11px] italic text-zinc-500 dark:text-zinc-400 leading-snug">
+								{{ turn.rationale }}
+							</p>
+							<div class="flex items-center gap-1.5 flex-wrap">
+								<span v-if="revisionSeq(turn)"
+									class="px-1.5 py-px rounded bg-secondary/15 text-secondary text-[9px] font-bold font-mono">
+									V{{ revisionSeq(turn) }}
+								</span>
+								<span v-for="chip in opChips(turn)" :key="chip"
+									class="px-1.5 py-px rounded bg-zinc-200/70 dark:bg-zinc-800 text-[9px] font-bold text-zinc-500">
+									{{ chip }}
+								</span>
+								<span v-if="turn.cost" class="text-[9px] font-mono text-zinc-400 ml-auto">
+									${{ turn.cost.toFixed(4) }}
+								</span>
+							</div>
+							<p v-if="turn.droppedOps?.length" class="text-[9px] text-amber-500 leading-snug">
+								{{ turn.droppedOps.length }} op{{ turn.droppedOps.length === 1 ? '' : 's' }} dropped during validation
+							</p>
+						</div>
+					</div>
+				</div>
+			</template>
+		</div>
+
+		<!-- Latest applied result actions (Back to parent, etc.) -->
+		<AiResultCard v-if="store.lastResult" class="shrink-0 mx-2 mb-2" />
+
+		<!-- Input, pinned — the border-t is the only frame around it -->
+		<div class="shrink-0 border-t border-zinc-200/60 dark:border-zinc-800 px-3 pt-2 pb-2.5">
+			<PromptBar />
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, nextTick, ref, watch } from 'vue'
+import type { PromptTurn } from '@shared/types'
+import { useEditorStore } from '../../stores/editorStore'
+import PromptBar from './PromptBar.vue'
+import AiResultCard from './AiResultCard.vue'
+
+const store = useEditorStore()
+
+const scrollRef = ref<HTMLElement | null>(null)
+
+const turns = computed<PromptTurn[]>(() =>
+	[...(store.doc?.turns || [])].sort((a, b) => a.createdAt - b.createdAt)
+)
+
+const personaIcon = (personaId: string) => store.findPersona?.(personaId)?.icon
+	|| store.personas.find((p) => p.id === personaId)?.icon
+	|| '🤖'
+
+const revisionSeq = (turn: PromptTurn) => {
+	if (!turn.revisionId) return null
+	return store.revisions.find((r) => r.id === turn.revisionId)?.seq ?? null
+}
+
+const opChips = (turn: PromptTurn) => {
+	const d = turn.diff
+	if (!d) return []
+	const chips: string[] = []
+	if (d.addItems?.length) chips.push(`+${d.addItems.length} added`)
+	if (d.removeItemIds?.length) chips.push(`−${d.removeItemIds.length} removed`)
+	if (d.updateItems?.length) chips.push(`${d.updateItems.length} changed`)
+	return chips
+}
+
+const formatTime = (ts: number) => {
+	const d = new Date(ts)
+	return `${d.getHours()}:${String(d.getMinutes()).padStart(2, '0')}`
+}
+
+// Follow the conversation: stick to the bottom when turns change/stream
+const scrollToBottom = () => {
+	nextTick(() => {
+		const el = scrollRef.value
+		if (el) el.scrollTop = el.scrollHeight
+	})
+}
+watch(() => [turns.value.length, turns.value[turns.value.length - 1]?.status], scrollToBottom, { immediate: true })
+</script>
diff --git a/src/renderer/src/editor/components/ClipTile.vue b/src/renderer/src/editor/components/ClipTile.vue
new file mode 100644
index 0000000..e2b643f
--- /dev/null
+++ b/src/renderer/src/editor/components/ClipTile.vue
@@ -0,0 +1,85 @@
+<template>
+	<div class="relative w-20 shrink-0 cursor-pointer group" @click="onClick"
+		draggable="true" tabindex="0"
+		:title="'Drag to the timeline, or press Enter to place at the playhead'"
+		@dragstart="onDragStart" @keydown.enter.prevent="placeAtPlayhead">
+		<!-- Thumb -->
+		<div class="w-20 h-12 rounded-lg overflow-hidden border-2 transition bg-zinc-200 dark:bg-zinc-800"
+			:class="clip.selected
+				? 'border-primary ring-1 ring-primary/30'
+				: active
+					? 'border-secondary/60'
+					: 'border-transparent group-hover:border-zinc-300 dark:group-hover:border-zinc-600'">
+			<img v-if="clip.thumbnailPath" :src="`media://${clip.thumbnailPath}`"
+				class="w-full h-full object-cover" loading="lazy" />
+			<div v-else class="w-full h-full flex items-center justify-center">
+				<span class="iconify w-4 h-4 text-zinc-400"
+					:class="isAudio ? 'tabler--music' : 'tabler--photo'"></span>
+			</div>
+		</div>
+
+		<!-- Selection toggle (always visible when selected; on hover otherwise) -->
+		<button
+			class="absolute top-0.5 right-0.5 w-4 h-4 rounded-full flex items-center justify-center shadow transition"
+			:class="clip.selected
+				? 'bg-primary'
+				: 'bg-zinc-900/50 opacity-0 group-hover:opacity-100 hover:bg-primary/80'"
+			title="Toggle piece selection"
+			@click.stop="editorStore.toggleClipSelected(clip.id)">
+			<span class="iconify tabler--check w-2.5 h-2.5 text-white"></span>
+		</button>
+
+		<!-- Index + timecode -->
+		<div class="mt-1 flex items-center justify-between px-0.5">
+			<span class="text-[9px] font-bold text-zinc-500">#{{ clip.index }}</span>
+			<span class="text-[8px] font-mono text-zinc-400">{{ timecode }}</span>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { Clip } from '@shared/types'
+import { useEditorStore } from '../../stores/editorStore'
+
+const props = defineProps<{
+	clip: Clip
+	active: boolean
+}>()
+
+const editorStore = useEditorStore()
+
+const isAudio = computed(() =>
+	editorStore.assets.find((a) => a.id === props.clip.sourceAssetId)?.kind === 'audio')
+
+const format = (seconds: number) => {
+	const m = Math.floor(seconds / 60)
+	const s = Math.floor(seconds % 60)
+	return `${m}:${String(s).padStart(2, '0')}`
+}
+
+const timecode = computed(() => `${format(props.clip.in)}–${format(props.clip.out)}`)
+
+const onClick = (event: MouseEvent) => {
+	// Plain click: focus the clip (preview + inspector). Cmd/Ctrl+click: toggle selection.
+	if (event.metaKey || event.ctrlKey) {
+		editorStore.toggleClipSelected(props.clip.id)
+	} else {
+		editorStore.selectClip(props.clip.id === editorStore.selectedClipId ? null : props.clip.id)
+	}
+}
+
+const onDragStart = (event: DragEvent) => {
+	if (!event.dataTransfer) return
+	event.dataTransfer.setData('application/x-frameflow-clip', props.clip.id)
+	// Kind hint (readable during dragover, unlike the payload) so a lane can
+	// accept/reject before drop: audio clips → audio lanes, else video lanes.
+	event.dataTransfer.setData(`application/x-frameflow-kind-${isAudio.value ? 'audio' : 'video'}`, '1')
+	event.dataTransfer.effectAllowed = 'copy'
+}
+
+// Keyboard-only placement path: Enter drops the piece at the playhead
+const placeAtPlayhead = () => {
+	editorStore.addItemFromClip(props.clip.id, null, editorStore.playheadSec)
+}
+</script>
diff --git a/src/renderer/src/editor/components/ClipTray.vue b/src/renderer/src/editor/components/ClipTray.vue
new file mode 100644
index 0000000..b47e449
--- /dev/null
+++ b/src/renderer/src/editor/components/ClipTray.vue
@@ -0,0 +1,113 @@
+<template>
+	<div class="border-t border-zinc-200 dark:border-zinc-800 px-3 py-2.5">
+		<div class="flex items-center justify-between mb-2">
+			<span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500">
+				Pieces
+				<span v-if="clips.length > 0" class="text-zinc-400 normal-case tracking-normal font-mono ml-1">
+					{{ selectedCount }}/{{ clips.length }}
+				</span>
+			</span>
+
+			<div class="flex items-center gap-0.5">
+				<!-- Merge / split selected pieces (§5.2 corrections) -->
+				<button v-if="selectedCount >= 2" title="Merge selected pieces"
+					class="p-1 rounded-md text-zinc-400 hover:text-primary hover:bg-primary/10 transition"
+					@click="onMerge">
+					<span class="iconify tabler--arrows-join w-3.5 h-3.5 block"></span>
+				</button>
+				<button v-if="selectedCount >= 1" title="Split selected pieces in half"
+					class="p-1 rounded-md text-zinc-400 hover:text-primary hover:bg-primary/10 transition"
+					@click="onSplit">
+					<span class="iconify tabler--arrows-split-2 w-3.5 h-3.5 block"></span>
+				</button>
+				<!-- Detector sensitivity toggle (scene-based; N/A for audio) -->
+				<button v-if="!isAudio" title="Scene detector sensitivity"
+					class="p-1 rounded-md transition"
+					:class="showDetector ? 'text-primary bg-primary/10' : 'text-zinc-400 hover:text-primary hover:bg-primary/10'"
+					@click="showDetector = !showDetector">
+					<span class="iconify tabler--adjustments-horizontal w-3.5 h-3.5 block"></span>
+				</button>
+			</div>
+		</div>
+
+		<!-- Detector sensitivity (§5.2) — re-runs scene detection -->
+		<div v-if="showDetector && !isAudio" class="mb-2 p-2 rounded-lg bg-zinc-100/70 dark:bg-zinc-900/50">
+			<div class="flex items-center gap-2">
+				<span class="text-[9px] font-bold uppercase tracking-widest text-zinc-400 shrink-0">Threshold</span>
+				<input type="range" min="5" max="60" step="1" v-model.number="threshold"
+					class="flex-1 accent-primary min-w-0" />
+				<span class="font-mono text-[11px] text-zinc-600 dark:text-zinc-300 w-6 text-right">{{ threshold }}</span>
+			</div>
+			<div class="mt-1.5 flex items-center justify-between gap-2">
+				<p class="text-[9px] text-zinc-400 leading-snug">
+					Lower finds more pieces. Re-detecting rebuilds the tray (manual merges/splits are lost).
+				</p>
+				<button
+					class="shrink-0 px-2 py-1 rounded-lg border border-primary/40 text-primary text-[10px] font-bold hover:bg-primary/10 transition active:scale-95 disabled:opacity-50"
+					:disabled="isProcessing || !asset" @click="onRedetect">
+					Re-detect
+				</button>
+			</div>
+		</div>
+
+		<p v-if="trayError" class="mb-1.5 text-[10px] text-red-500">{{ trayError }}</p>
+
+		<!-- Skeletons while scene detection / thumbnails run -->
+		<div v-if="isProcessing && clips.length === 0" class="flex gap-2 overflow-hidden">
+			<div v-for="i in 4" :key="i"
+				class="w-20 h-12 rounded-lg bg-zinc-200 dark:bg-zinc-800 animate-pulse-soft shrink-0"></div>
+		</div>
+
+		<!-- No pieces -->
+		<p v-else-if="clips.length === 0 && asset?.preprocessState === 'completed'"
+			class="text-[11px] text-zinc-400 py-2">
+			{{ isAudio ? 'No pieces in this audio.' : 'No scenes detected in this video.' }}
+		</p>
+
+		<p v-else-if="clips.length === 0" class="text-[11px] text-zinc-400 py-2">
+			Pieces appear here after processing.
+		</p>
+
+		<!-- Clip tiles -->
+		<div v-else class="flex gap-2 overflow-x-auto custom-scrollbar pb-1">
+			<ClipTile v-for="clip in clips" :key="clip.id" :clip="clip"
+				:active="clip.id === editorStore.selectedClipId" />
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+import ClipTile from './ClipTile.vue'
+
+const editorStore = useEditorStore()
+
+const asset = computed(() => editorStore.selectedAsset)
+const isAudio = computed(() => asset.value?.kind === 'audio')
+const clips = computed(() => asset.value?.clips ?? [])
+const selectedCount = computed(() => clips.value.filter((c) => c.selected).length)
+const isProcessing = computed(() => asset.value?.preprocessState === 'running')
+
+const showDetector = ref(false)
+const threshold = ref(27) // PySceneDetect detect-content default
+const trayError = ref<string | null>(null)
+
+watch(() => asset.value?.id, () => { trayError.value = null })
+
+const onRedetect = () => {
+	if (!asset.value) return
+	trayError.value = null
+	editorStore.redetectScenes(asset.value.id, threshold.value)
+}
+
+const onMerge = async () => {
+	if (!asset.value) return
+	trayError.value = await editorStore.mergeSelectedClips(asset.value.id)
+}
+
+const onSplit = async () => {
+	if (!asset.value) return
+	trayError.value = await editorStore.splitSelectedClips(asset.value.id)
+}
+</script>
diff --git a/src/renderer/src/editor/components/ExportDialog.vue b/src/renderer/src/editor/components/ExportDialog.vue
new file mode 100644
index 0000000..bfbc1f6
--- /dev/null
+++ b/src/renderer/src/editor/components/ExportDialog.vue
@@ -0,0 +1,160 @@
+<template>
+	<Modal :model-value="modelValue" title="Export video" size="md"
+		@update:model-value="$emit('update:modelValue', $event)">
+		<div class="py-2 space-y-4">
+			<!-- ===== Idle: options ===== -->
+			<template v-if="!state">
+				<div>
+					<span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-2">Quality</span>
+					<label v-for="option in qualityOptions" :key="option.value"
+						class="flex items-start gap-2.5 p-2.5 rounded-xl border cursor-pointer transition mb-2"
+						:class="quality === option.value
+							? 'border-primary/50 bg-primary/5 ring-1 ring-primary/20'
+							: 'border-zinc-200 dark:border-zinc-800 hover:border-primary/30'">
+						<input type="radio" class="accent-primary mt-0.5" :value="option.value" v-model="quality" />
+						<div>
+							<p class="text-xs font-bold text-zinc-800 dark:text-zinc-200">{{ option.label }}</p>
+							<p class="text-[10px] text-zinc-500 leading-snug">{{ option.description }}</p>
+						</div>
+					</label>
+				</div>
+
+				<p v-if="store.exportNotice"
+					class="px-2.5 py-1.5 rounded-lg bg-amber-500/10 border border-amber-500/20 text-[10px] font-medium text-amber-600 dark:text-amber-400 leading-snug">
+					<span class="iconify tabler--alert-triangle w-3 h-3 inline-block align-[-1px] mr-1"></span>
+					{{ store.exportNotice }}
+				</p>
+			</template>
+
+			<!-- ===== Rendering / stitching ===== -->
+			<template v-else-if="store.isRendering">
+				<div class="py-3 text-center">
+					<p class="text-sm font-bold text-zinc-800 dark:text-zinc-200 font-heading mb-1">
+						{{ state.phase === 'stitching' ? 'Finalizing…' : 'Rendering regions…' }}
+					</p>
+					<p class="text-[10px] text-zinc-400">Your timeline is being rendered with FFmpeg.</p>
+				</div>
+				<div class="h-2 rounded-full bg-zinc-200 dark:bg-zinc-800 overflow-hidden">
+					<div class="h-full bg-primary rounded-full transition-all duration-300"
+						:style="{ width: `${state.percent}%` }"></div>
+				</div>
+				<p class="text-center text-[11px] font-mono text-zinc-500">{{ state.percent }}%</p>
+			</template>
+
+			<!-- ===== Done ===== -->
+			<template v-else-if="state.phase === 'done'">
+				<div class="py-3 text-center">
+					<div class="w-12 h-12 mx-auto rounded-2xl bg-accent/10 flex items-center justify-center text-accent mb-3">
+						<span class="iconify tabler--check w-6 h-6"></span>
+					</div>
+					<p class="text-sm font-bold text-zinc-800 dark:text-zinc-200 font-heading">Export complete</p>
+					<p class="mt-1 text-[10px] font-mono text-zinc-400 break-all px-4">{{ fileName }}</p>
+				</div>
+			</template>
+
+			<!-- ===== Error / canceled ===== -->
+			<template v-else>
+				<div class="py-3 text-center">
+					<div class="w-12 h-12 mx-auto rounded-2xl flex items-center justify-center mb-3"
+						:class="isCanceled ? 'bg-zinc-500/10 text-zinc-400' : 'bg-red-500/10 text-red-500'">
+						<span :class="isCanceled ? 'iconify tabler--player-stop' : 'iconify tabler--alert-triangle'" class="w-6 h-6"></span>
+					</div>
+					<p class="text-sm font-bold text-zinc-800 dark:text-zinc-200 font-heading">
+						{{ isCanceled ? 'Export canceled' : 'Export failed' }}
+					</p>
+					<p v-if="!isCanceled" class="mt-1 text-[11px] text-red-500 leading-snug px-4">{{ state.error }}</p>
+				</div>
+			</template>
+		</div>
+
+		<template #footer>
+			<div class="flex justify-end gap-2 w-full">
+				<!-- Idle -->
+				<template v-if="!state">
+					<button class="btn-ghost" @click="close">Cancel</button>
+					<button class="btn-primary" :disabled="!store.canExport" @click="store.startExport(quality)">
+						<span class="iconify tabler--file-export w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+						Export
+					</button>
+				</template>
+				<!-- Rendering -->
+				<template v-else-if="store.isRendering">
+					<button class="btn-ghost !text-red-500 hover:!bg-red-500/10" @click="store.abortExport()">
+						Cancel render
+					</button>
+				</template>
+				<!-- Done -->
+				<template v-else-if="state.phase === 'done'">
+					<button class="btn-ghost" @click="openFolder">Open folder</button>
+					<button class="btn-ghost" @click="finish">Done</button>
+					<button class="btn-primary" @click="saveAs">
+						<span class="iconify tabler--download w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+						Save As…
+					</button>
+				</template>
+				<!-- Error -->
+				<template v-else>
+					<button class="btn-ghost" @click="close">Close</button>
+					<button class="btn-primary" @click="store.clearRenderState()">Retry</button>
+				</template>
+			</div>
+		</template>
+	</Modal>
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+import { Modal } from 'pilotui/complex'
+import { useEditorStore } from '../../stores/editorStore'
+
+defineProps<{ modelValue: boolean }>()
+const emit = defineEmits<{ (e: 'update:modelValue', value: boolean): void }>()
+
+const store = useEditorStore()
+const quality = ref<'original' | 'preview'>('original')
+
+const state = computed(() => store.renderState)
+const isCanceled = computed(() => state.value?.error === 'aborted')
+const fileName = computed(() => state.value?.outputPath?.split('/').pop() || '')
+
+const qualityOptions = [
+	{
+		value: 'original' as const,
+		label: 'Original quality',
+		description: 'Renders from the source files at full resolution.'
+	},
+	{
+		value: 'preview' as const,
+		label: 'Fast preview (480p)',
+		description: 'Renders from the 480p proxies — much faster, lower quality.'
+	}
+]
+
+// Closing the dialog does NOT abort — the render continues and the header
+// button keeps showing progress (reopen anytime).
+const close = () => emit('update:modelValue', false)
+
+const finish = () => {
+	store.clearRenderState()
+	close()
+}
+
+const saveAs = async () => {
+	const outputPath = state.value?.outputPath
+	if (!outputPath) return
+	await (window as any).api.saveVideo(outputPath)
+}
+
+const openFolder = () => {
+	if (store.threadId) (window as any).api.openThreadDir(store.threadId)
+}
+</script>
+
+<style scoped>
+.btn-ghost {
+	@apply px-4 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 text-xs font-bold text-zinc-600 dark:text-zinc-300 hover:bg-zinc-100 dark:hover:bg-zinc-800 transition active:scale-95;
+}
+.btn-primary {
+	@apply px-4 py-2 rounded-xl bg-primary text-white text-xs font-bold shadow-md shadow-primary/20 hover:bg-primary-dark transition active:scale-95 disabled:opacity-50 disabled:cursor-not-allowed;
+}
+</style>
diff --git a/src/renderer/src/editor/components/ImportMediaModal.vue b/src/renderer/src/editor/components/ImportMediaModal.vue
new file mode 100644
index 0000000..51d3fa1
--- /dev/null
+++ b/src/renderer/src/editor/components/ImportMediaModal.vue
@@ -0,0 +1,136 @@
+<template>
+	<Modal :model-value="modelValue" title="Import media from URL" size="md"
+		@update:model-value="$emit('update:modelValue', $event)">
+		<div class="space-y-4 py-2">
+			<div>
+				<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">
+					Video URL
+				</label>
+				<Input v-model="url" placeholder="https://youtube.com/watch?v=… or direct link"
+					:disabled="importing" @keyup.enter="fetchFormats" />
+			</div>
+
+			<!-- Resolution picker (after formats fetched) -->
+			<div v-if="resolutions.length > 0">
+				<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">
+					Resolution
+				</label>
+				<select v-model="resolution"
+					class="w-full px-3 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 bg-white dark:bg-zinc-900 text-sm text-zinc-800 dark:text-zinc-200 input-focus-ring"
+					:disabled="importing">
+					<option v-for="res in resolutions" :key="res" :value="res">{{ res }}</option>
+				</select>
+			</div>
+
+			<!-- Progress -->
+			<div v-if="importing">
+				<div class="h-1.5 rounded-full bg-zinc-200 dark:bg-zinc-800 overflow-hidden">
+					<div class="h-full bg-primary rounded-full transition-all duration-300"
+						:style="{ width: `${progress}%` }"></div>
+				</div>
+				<p class="mt-1.5 text-[10px] font-mono text-zinc-400 text-center">
+					{{ progress > 0 ? `${Math.round(progress)}%` : 'Starting download…' }}
+				</p>
+			</div>
+
+			<p v-if="error" class="text-xs text-red-500 font-medium leading-snug">{{ error }}</p>
+		</div>
+
+		<template #footer>
+			<div class="flex justify-end gap-2">
+				<button
+					class="px-4 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 text-xs font-bold text-zinc-600 dark:text-zinc-300 hover:bg-zinc-100 dark:hover:bg-zinc-800 transition"
+					:disabled="importing" @click="close">
+					Cancel
+				</button>
+				<button v-if="resolutions.length === 0"
+					class="px-4 py-2 rounded-xl bg-primary text-white text-xs font-bold shadow-md shadow-primary/20 hover:bg-primary-dark transition disabled:opacity-50 disabled:cursor-not-allowed"
+					:disabled="!url.trim() || fetching" @click="fetchFormats">
+					{{ fetching ? 'Checking…' : 'Continue' }}
+				</button>
+				<button v-else
+					class="px-4 py-2 rounded-xl bg-primary text-white text-xs font-bold shadow-md shadow-primary/20 hover:bg-primary-dark transition disabled:opacity-50 disabled:cursor-not-allowed"
+					:disabled="importing" @click="startImport">
+					{{ importing ? 'Importing…' : 'Import' }}
+				</button>
+			</div>
+		</template>
+	</Modal>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+import { Modal } from 'pilotui/complex'
+import { Input } from 'pilotui/form'
+import { useEditorStore } from '../../stores/editorStore'
+
+const props = defineProps<{ modelValue: boolean }>()
+const emit = defineEmits<{ (e: 'update:modelValue', value: boolean): void }>()
+
+const editorStore = useEditorStore()
+
+const url = ref('')
+const resolutions = ref<string[]>([])
+const resolution = ref<string>('')
+const fetching = ref(false)
+const importing = ref(false)
+const error = ref('')
+const activeImportId = ref<string | null>(null)
+
+const progress = computed(() => {
+	if (!activeImportId.value) {
+		// Fall back to any in-flight import for this session
+		const entries = Object.values(editorStore.urlImports)
+		return entries.length > 0 ? entries[0].percent : 0
+	}
+	return editorStore.urlImports[activeImportId.value]?.percent ?? 0
+})
+
+watch(() => props.modelValue, (open) => {
+	if (open) reset()
+})
+
+const reset = () => {
+	url.value = ''
+	resolutions.value = []
+	resolution.value = ''
+	fetching.value = false
+	importing.value = false
+	error.value = ''
+	activeImportId.value = null
+}
+
+const close = () => emit('update:modelValue', false)
+
+const fetchFormats = async () => {
+	if (!url.value.trim() || fetching.value) return
+	fetching.value = true
+	error.value = ''
+	try {
+		const formats = await (window as any).api.fetchVideoFormats(url.value.trim())
+		const list: string[] = Array.isArray(formats)
+			? formats
+			: (formats?.resolutions || [])
+		resolutions.value = list.length > 0 ? list : ['best']
+		resolution.value = resolutions.value[Math.min(1, resolutions.value.length - 1)]
+	} catch (err: any) {
+		error.value = err?.message || 'Could not read this URL. Check the link and try again.'
+	} finally {
+		fetching.value = false
+	}
+}
+
+const startImport = async () => {
+	if (importing.value) return
+	importing.value = true
+	error.value = ''
+	try {
+		await editorStore.importUrl(url.value.trim(), resolution.value || undefined)
+		close()
+	} catch (err: any) {
+		error.value = err?.message || 'Import failed. Check the URL and your connection.'
+	} finally {
+		importing.value = false
+	}
+}
+</script>
diff --git a/src/renderer/src/editor/components/InspectorPanel.vue b/src/renderer/src/editor/components/InspectorPanel.vue
new file mode 100644
index 0000000..b019b89
--- /dev/null
+++ b/src/renderer/src/editor/components/InspectorPanel.vue
@@ -0,0 +1,299 @@
+<template>
+	<div class="glass-card rounded-2xl flex flex-col min-h-0 overflow-hidden">
+		<div class="px-4 pt-4 pb-2 shrink-0">
+			<span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500">Inspector</span>
+		</div>
+
+		<div class="flex-1 min-h-0 overflow-y-auto custom-scrollbar px-4 pb-4">
+			<!-- Timeline-item mode (priority when items are selected) -->
+			<template v-if="timelineItem">
+				<h3 class="text-sm font-bold text-zinc-800 dark:text-zinc-200 font-heading truncate">
+					{{ timelineItem.label || 'Timeline clip' }}
+				</h3>
+
+				<dl class="mt-3 space-y-2">
+					<MetaRow label="Track" :value="trackName" />
+					<MetaRow label="Start" :value="formatTime(timelineItem.timelineStart)" mono />
+					<MetaRow label="Source in" :value="formatTime(timelineItem.in)" mono />
+					<MetaRow label="Source out" :value="formatTime(timelineItem.out)" mono />
+				</dl>
+
+				<!-- Retime: speed OR exact duration (PRD §5.6 numeric path) -->
+				<div class="mt-4 space-y-3">
+					<div>
+						<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1">
+							Speed <span class="normal-case tracking-normal font-mono text-secondary ml-1">{{ timelineItem.speed.toFixed(2) }}×</span>
+						</label>
+						<input type="number" min="0.25" max="4" step="0.05" :value="timelineItem.speed"
+							class="w-full px-2 py-1.5 rounded-lg border border-zinc-200 dark:border-zinc-700 bg-white dark:bg-zinc-900 text-xs font-mono text-zinc-800 dark:text-zinc-200 input-focus-ring"
+							@change="onSpeedInput" />
+					</div>
+					<div>
+						<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1">
+							Duration (s)
+						</label>
+						<input type="number" min="0.05" step="0.1" :value="timelineItem.duration.toFixed(2)"
+							class="w-full px-2 py-1.5 rounded-lg border border-zinc-200 dark:border-zinc-700 bg-white dark:bg-zinc-900 text-xs font-mono text-zinc-800 dark:text-zinc-200 input-focus-ring"
+							@change="onDurationInput" />
+						<p class="mt-1 text-[9px] text-zinc-400 leading-snug">
+							Changing duration retimes the clip (same content, new speed) and ripples the track.
+						</p>
+					</div>
+					<label class="flex items-center gap-2 cursor-pointer">
+						<input type="checkbox" class="accent-primary" :checked="timelineItem.preservePitch"
+							@change="editorStore.setItemPreservePitch(timelineItem!.id, ($event.target as HTMLInputElement).checked)" />
+						<span class="text-[11px] text-zinc-600 dark:text-zinc-300">Preserve audio pitch when retimed</span>
+					</label>
+
+					<!-- Audio gain (mix level applied at export) -->
+					<div>
+						<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1">
+							Gain <span class="normal-case tracking-normal font-mono text-accent ml-1">{{ gainValue.toFixed(2) }}×</span>
+						</label>
+						<input type="range" min="0" max="2" step="0.05" :value="gainValue"
+							class="w-full accent-accent"
+							@change="editorStore.setItemGain(timelineItem!.id, parseFloat(($event.target as HTMLInputElement).value))" />
+						<p class="mt-1 text-[9px] text-zinc-400 leading-snug">
+							Level for this clip in the exported audio mix. 1.0× is unchanged.
+						</p>
+					</div>
+				</div>
+
+				<!-- Actions -->
+				<div class="mt-4 flex flex-col gap-2">
+					<button
+						class="w-full px-3 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 text-xs font-bold text-zinc-600 dark:text-zinc-300 hover:border-primary/40 hover:text-primary transition active:scale-95"
+						@click="editorStore.toggleItemMuted(timelineItem!.id)">
+						<span :class="timelineItem.muted ? 'iconify tabler--volume' : 'iconify tabler--volume-off'" class="w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+						{{ timelineItem.muted ? 'Unmute clip audio' : 'Mute clip audio' }}
+					</button>
+					<button
+						class="w-full px-3 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 text-xs font-bold text-zinc-600 dark:text-zinc-300 hover:border-primary/40 hover:text-primary transition active:scale-95"
+						@click="editorStore.splitAtPlayhead()">
+						<span class="iconify tabler--blade-filled w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+						Split at playhead
+					</button>
+					<button
+						class="w-full px-3 py-2 rounded-xl border border-red-200 dark:border-red-900/40 text-xs font-bold text-red-500 hover:bg-red-500/10 transition active:scale-95"
+						@click="editorStore.deleteItems([timelineItem!.id])">
+						<span class="iconify tabler--trash w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+						Ripple delete
+					</button>
+				</div>
+
+				<!-- Keep scanned silence results in view while inspecting items -->
+				<SilenceFinder v-if="editorStore.silenceScan?.assetId === timelineItem.sourceAssetId"
+					:asset-id="timelineItem.sourceAssetId" compact />
+			</template>
+
+			<!-- Multi-select mode -->
+			<template v-else-if="editorStore.selectedItemIds.length > 1">
+				<h3 class="text-sm font-bold text-zinc-800 dark:text-zinc-200 font-heading">
+					{{ editorStore.selectedItemIds.length }} clips selected
+				</h3>
+				<button
+					class="mt-4 w-full px-3 py-2 rounded-xl border border-red-200 dark:border-red-900/40 text-xs font-bold text-red-500 hover:bg-red-500/10 transition active:scale-95"
+					@click="editorStore.deleteItems(editorStore.selectedItemIds)">
+					<span class="iconify tabler--trash w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+					Ripple delete all
+				</button>
+			</template>
+
+			<!-- Clip mode -->
+			<template v-else-if="clip">
+				<div class="rounded-xl overflow-hidden mb-3 bg-zinc-200 dark:bg-zinc-800">
+					<img v-if="clip.thumbnailPath" :src="`media://${clip.thumbnailPath}`" class="w-full object-cover" />
+				</div>
+				<h3 class="text-sm font-bold text-zinc-800 dark:text-zinc-200 font-heading">Piece #{{ clip.index }}</h3>
+
+				<dl class="mt-3 space-y-2">
+					<MetaRow label="In" :value="formatTime(clip.in)" mono />
+					<MetaRow label="Out" :value="formatTime(clip.out)" mono />
+					<MetaRow label="Duration" :value="`${clip.duration.toFixed(2)}s`" mono />
+					<MetaRow label="Selected" :value="clip.selected ? 'Yes' : 'No'" />
+				</dl>
+
+				<!-- Context (visual description) -->
+				<div v-if="clip.visual" class="mt-4">
+					<span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500">Scene context</span>
+					<p class="mt-1.5 text-xs text-zinc-600 dark:text-zinc-300 leading-relaxed">{{ clip.visual }}</p>
+				</div>
+				<div v-if="clip.text" class="mt-3">
+					<span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500">Transcript</span>
+					<p class="mt-1.5 text-xs text-zinc-500 dark:text-zinc-400 leading-relaxed italic">{{ clip.text }}</p>
+				</div>
+
+				<!-- Keep scanned silence results in view while previewing pieces -->
+				<SilenceFinder v-if="editorStore.silenceScan?.assetId === clip.sourceAssetId"
+					:asset-id="clip.sourceAssetId" compact />
+			</template>
+
+			<!-- Asset mode -->
+			<template v-else-if="asset">
+				<h3 class="text-sm font-bold text-zinc-800 dark:text-zinc-200 font-heading break-words">{{ asset.name }}</h3>
+
+				<dl v-if="asset.metadata" class="mt-3 space-y-2">
+					<MetaRow label="Kind" :value="asset.kind === 'audio' ? 'Audio' : 'Video'" />
+					<MetaRow label="Duration" :value="formatTime(asset.metadata.duration)" mono />
+					<template v-if="asset.kind !== 'audio'">
+						<MetaRow label="Resolution" :value="`${asset.metadata.width}×${asset.metadata.height}`" mono />
+						<MetaRow label="FPS" :value="String(asset.metadata.fps)" mono />
+					</template>
+					<MetaRow label="Codec" :value="asset.metadata.codec" />
+					<MetaRow label="Size" :value="formatSize(asset.metadata.size)" mono />
+					<MetaRow v-if="asset.kind !== 'audio'" label="Audio" :value="asset.metadata.hasAudio ? 'Yes' : 'No'" />
+					<MetaRow label="Pieces" :value="String(asset.clips.length)" mono />
+				</dl>
+				<p v-else class="mt-3 text-xs text-zinc-400">Metadata unavailable for this file.</p>
+
+				<!-- Opt-in Gemini descriptions -->
+				<div v-if="asset.preprocessState === 'completed' && asset.clips.length > 0" class="mt-5">
+					<!-- Scene descriptions are visual (thumbnail-derived) — video only -->
+					<template v-if="asset.kind !== 'audio'">
+						<button v-if="!hasDescriptions"
+							class="w-full px-3 py-2 rounded-xl border border-secondary/40 text-secondary text-xs font-bold hover:bg-secondary/10 transition active:scale-95 disabled:opacity-50"
+							:disabled="describing" @click="describe">
+							<span class="iconify tabler--sparkles w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+							{{ describing ? 'Describing scenes…' : 'Describe scenes (uses Gemini)' }}
+						</button>
+						<p v-if="!hasDescriptions" class="mt-1.5 text-[10px] text-zinc-400 leading-snug">
+							Generates a one-line description per piece for the context view. Costs tokens.
+						</p>
+						<div v-else class="flex items-center justify-between gap-2">
+							<p class="text-[11px] text-accent font-medium">
+								<span class="iconify tabler--check w-3 h-3 inline-block align-[-1px]"></span>
+								Scene descriptions ready
+							</p>
+							<button class="text-[10px] font-bold uppercase tracking-widest text-zinc-400 hover:text-red-500 transition"
+								@click="editorStore.clearAssetData(asset.id, 'descriptions')">
+								Remove
+							</button>
+						</div>
+					</template>
+
+					<!-- Opt-in Gemini transcript -->
+					<div :class="asset.kind !== 'audio' ? 'mt-3' : ''">
+						<button v-if="!hasTranscript"
+							class="w-full px-3 py-2 rounded-xl border border-secondary/40 text-secondary text-xs font-bold hover:bg-secondary/10 transition active:scale-95 disabled:opacity-50"
+							:disabled="transcribing" @click="transcribe">
+							<span class="iconify tabler--file-text w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+							{{ transcribing ? 'Transcribing…' : 'Transcribe (uses Gemini)' }}
+						</button>
+						<p v-if="!hasTranscript" class="mt-1.5 text-[10px] text-zinc-400 leading-snug">
+							Adds spoken text to each piece and enriches AI editing context. Costs tokens.
+						</p>
+						<div v-else class="flex items-center justify-between gap-2">
+							<p class="text-[11px] text-accent font-medium">
+								<span class="iconify tabler--check w-3 h-3 inline-block align-[-1px]"></span>
+								Transcript ready
+							</p>
+							<button class="text-[10px] font-bold uppercase tracking-widest text-zinc-400 hover:text-red-500 transition"
+								@click="editorStore.clearAssetData(asset.id, 'transcript')">
+								Remove
+							</button>
+						</div>
+					</div>
+				</div>
+
+				<!-- Silence / dead-air finder (§5.6) — assistive, review-only -->
+				<SilenceFinder v-if="asset.metadata?.hasAudio !== false" :asset-id="asset.id" />
+			</template>
+
+			<!-- Empty -->
+			<div v-else class="h-full flex flex-col items-center justify-center gap-2 text-center py-8">
+				<span class="iconify tabler--click w-6 h-6 text-zinc-300 dark:text-zinc-600"></span>
+				<p class="text-xs text-zinc-400">Select a media file or piece to inspect it.</p>
+			</div>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, h, ref } from 'vue'
+import type { FunctionalComponent } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+import SilenceFinder from './SilenceFinder.vue'
+
+const editorStore = useEditorStore()
+
+const clip = computed(() => editorStore.selectedClip)
+const asset = computed(() => editorStore.selectedAsset)
+const describing = ref(false)
+const transcribing = ref(false)
+
+// Timeline-item mode: single selected item takes priority over clip/asset
+const timelineItem = computed(() =>
+	editorStore.selectedItemIds.length === 1
+		? editorStore.doc?.timeline.find((i) => i.id === editorStore.selectedItemIds[0]) || null
+		: null
+)
+
+const trackName = computed(() =>
+	editorStore.doc?.tracks.find((t) => t.id === timelineItem.value?.trackId)?.name || '—'
+)
+
+const gainValue = computed(() => timelineItem.value?.gain ?? 1)
+
+const onSpeedInput = (event: Event) => {
+	const value = parseFloat((event.target as HTMLInputElement).value)
+	if (timelineItem.value && Number.isFinite(value) && value > 0) {
+		editorStore.setItemSpeed(timelineItem.value.id, value)
+	}
+}
+
+const onDurationInput = (event: Event) => {
+	const value = parseFloat((event.target as HTMLInputElement).value)
+	if (timelineItem.value && Number.isFinite(value) && value > 0) {
+		editorStore.setItemTargetDuration(timelineItem.value.id, value)
+	}
+}
+
+const hasDescriptions = computed(() =>
+	(asset.value?.clips || []).some((c) => !!c.visual)
+)
+
+const hasTranscript = computed(() =>
+	(asset.value?.clips || []).some((c) => !!c.text)
+)
+
+const formatTime = (seconds: number) => {
+	const m = Math.floor(seconds / 60)
+	const s = Math.floor(seconds % 60)
+	const ms = Math.floor((seconds % 1) * 100)
+	return `${m}:${String(s).padStart(2, '0')}.${String(ms).padStart(2, '0')}`
+}
+
+const formatSize = (bytes: number) => {
+	if (bytes > 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`
+	return `${(bytes / 1024 / 1024).toFixed(1)} MB`
+}
+
+const describe = async () => {
+	if (!asset.value) return
+	describing.value = true
+	try {
+		await editorStore.describeAsset(asset.value.id)
+	} finally {
+		describing.value = false
+	}
+}
+
+const transcribe = async () => {
+	if (!asset.value) return
+	transcribing.value = true
+	try {
+		await editorStore.transcribeAsset(asset.value.id)
+	} finally {
+		transcribing.value = false
+	}
+}
+
+// Small label/value row
+const MetaRow: FunctionalComponent<{ label: string; value: string; mono?: boolean }> = (props) =>
+	h('div', { class: 'flex items-center justify-between gap-3' }, [
+		h('dt', { class: 'text-[10px] font-bold uppercase tracking-widest text-zinc-400 shrink-0' }, props.label),
+		h('dd', {
+			class: ['text-xs text-zinc-700 dark:text-zinc-200 truncate', props.mono ? 'font-mono' : 'font-medium']
+		}, props.value)
+	])
+</script>
diff --git a/src/renderer/src/editor/components/MediaPanel.vue b/src/renderer/src/editor/components/MediaPanel.vue
new file mode 100644
index 0000000..c34b7b5
--- /dev/null
+++ b/src/renderer/src/editor/components/MediaPanel.vue
@@ -0,0 +1,109 @@
+<template>
+	<div class="glass-card rounded-2xl flex flex-col min-h-0 overflow-hidden">
+		<!-- Panel header -->
+		<div class="px-4 pt-4 pb-2 flex items-center justify-between shrink-0">
+			<span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500">Media</span>
+			<div class="flex items-center gap-1">
+				<SlimTooltip text="Add local media" placement="bottom">
+					<button
+						class="w-7 h-7 flex items-center justify-center rounded-lg text-zinc-500 hover:text-primary hover:bg-primary/10 transition active:scale-95"
+						@click="editorStore.addLocalMedia()">
+						<span class="iconify tabler--plus w-4 h-4"></span>
+					</button>
+				</SlimTooltip>
+				<SlimTooltip text="Import from URL" placement="bottom">
+					<button
+						class="w-7 h-7 flex items-center justify-center rounded-lg text-zinc-500 hover:text-primary hover:bg-primary/10 transition active:scale-95"
+						@click="showImportModal = true">
+						<span class="iconify tabler--link w-4 h-4"></span>
+					</button>
+				</SlimTooltip>
+				<SlimTooltip text="Collapse panel" placement="bottom">
+					<button
+						class="w-7 h-7 flex items-center justify-center rounded-lg text-zinc-400 hover:text-primary hover:bg-primary/10 transition active:scale-95"
+						@click="$emit('update:collapsed', true)">
+						<span class="iconify tabler--layout-sidebar-left-collapse w-4 h-4"></span>
+					</button>
+				</SlimTooltip>
+			</div>
+		</div>
+
+		<!-- Dependency banner -->
+		<div v-if="!editorStore.deps.scenedetect"
+			class="mx-3 mb-2 px-3 py-2 rounded-xl bg-amber-500/10 border border-amber-500/20 shrink-0">
+			<p class="text-[11px] font-medium text-amber-600 dark:text-amber-400 leading-snug">
+				<span class="iconify tabler--alert-triangle w-3 h-3 inline-block align-[-1px] mr-1"></span>
+				Scene detection needs PySceneDetect. Media can still be imported and previewed.
+			</p>
+		</div>
+
+		<!-- Asset list -->
+		<div class="flex-1 min-h-0 overflow-y-auto custom-scrollbar px-3 pb-2">
+			<!-- Empty state -->
+			<div v-if="editorStore.isEmpty && !hasActiveImports"
+				class="h-full flex flex-col items-center justify-center text-center gap-4 py-8">
+				<div
+					class="w-14 h-14 rounded-2xl bg-primary/10 flex items-center justify-center text-primary">
+					<span class="iconify tabler--movie w-7 h-7"></span>
+				</div>
+				<div>
+					<p class="text-sm font-bold text-zinc-800 dark:text-zinc-200">No media yet</p>
+					<p class="text-xs text-zinc-500 dark:text-zinc-400 mt-1 leading-relaxed px-2">
+						Add video or audio and it will be broken into selectable pieces.
+					</p>
+				</div>
+				<div class="flex flex-col gap-2 w-full px-2">
+					<button
+						class="w-full px-3 py-2 rounded-xl bg-primary text-white text-xs font-bold shadow-md shadow-primary/20 hover:bg-primary-dark transition active:scale-95"
+						@click="editorStore.addLocalMedia()">
+						Add local media
+					</button>
+					<button
+						class="w-full px-3 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 text-xs font-bold text-zinc-600 dark:text-zinc-300 hover:border-primary/40 hover:text-primary transition active:scale-95"
+						@click="showImportModal = true">
+						Import from URL
+					</button>
+				</div>
+			</div>
+
+			<template v-else>
+				<!-- In-flight URL imports (no asset row yet) -->
+				<div v-for="(imp, assetId) in editorStore.urlImports" :key="'imp-' + assetId"
+					class="mb-2 p-3 rounded-xl border border-zinc-200 dark:border-zinc-800 bg-white/50 dark:bg-zinc-900/50">
+					<p class="text-xs font-medium text-zinc-600 dark:text-zinc-300 truncate">{{ imp.url || 'Downloading…' }}</p>
+					<div class="mt-2 h-1.5 rounded-full bg-zinc-200 dark:bg-zinc-800 overflow-hidden">
+						<div class="h-full bg-primary rounded-full transition-all duration-300"
+							:style="{ width: `${imp.percent}%` }"></div>
+					</div>
+					<p class="mt-1 text-[10px] font-mono text-zinc-400">{{ Math.round(imp.percent) }}%</p>
+				</div>
+
+				<AssetRow v-for="asset in editorStore.assets" :key="asset.id" :asset="asset"
+					:active="asset.id === editorStore.selectedAssetId"
+					@select="editorStore.selectAsset(asset.id)" />
+			</template>
+		</div>
+
+		<!-- Clip tray for the selected asset -->
+		<ClipTray v-if="editorStore.selectedAsset" class="shrink-0" />
+
+		<ImportMediaModal v-model="showImportModal" />
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+import SlimTooltip from '../../components/SlimTooltip.vue'
+import { useEditorStore } from '../../stores/editorStore'
+import AssetRow from './AssetRow.vue'
+import ClipTray from './ClipTray.vue'
+import ImportMediaModal from './ImportMediaModal.vue'
+
+defineProps<{ collapsed?: boolean }>()
+defineEmits<{ (e: 'update:collapsed', value: boolean): void }>()
+
+const editorStore = useEditorStore()
+const showImportModal = ref(false)
+
+const hasActiveImports = computed(() => Object.keys(editorStore.urlImports).length > 0)
+</script>
diff --git a/src/renderer/src/editor/components/PersonaEditorModal.vue b/src/renderer/src/editor/components/PersonaEditorModal.vue
new file mode 100644
index 0000000..8f63ffc
--- /dev/null
+++ b/src/renderer/src/editor/components/PersonaEditorModal.vue
@@ -0,0 +1,190 @@
+<template>
+	<Modal :model-value="modelValue" :title="isEdit ? 'Edit persona' : 'New persona'" size="lg"
+		@update:model-value="$emit('update:modelValue', $event)">
+		<div class="space-y-4 py-2 max-h-[60vh] overflow-y-auto custom-scrollbar pr-1">
+			<div class="grid grid-cols-[64px_1fr] gap-3">
+				<div>
+					<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">Icon</label>
+					<Input v-model="form.icon" placeholder="🎬" />
+				</div>
+				<div>
+					<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">Name *</label>
+					<Input v-model="form.name" placeholder="My editor persona" />
+				</div>
+			</div>
+
+			<div>
+				<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">Description</label>
+				<Input v-model="form.description" placeholder="One line shown in the picker" />
+			</div>
+
+			<div class="grid grid-cols-3 gap-3">
+				<div>
+					<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">Mode</label>
+					<select v-model="form.mode" class="w-full px-3 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 bg-white dark:bg-zinc-900 text-sm input-focus-ring">
+						<option value="longform">Long-form</option>
+						<option value="summarize">Summarize</option>
+					</select>
+				</div>
+				<div>
+					<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">Tone</label>
+					<Input v-model="form.tone" placeholder="neutral" />
+				</div>
+				<div>
+					<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">Pacing</label>
+					<select v-model="form.pacing" class="w-full px-3 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 bg-white dark:bg-zinc-900 text-sm input-focus-ring">
+						<option value="tight">Tight</option>
+						<option value="balanced">Balanced</option>
+						<option value="relaxed">Relaxed</option>
+					</select>
+				</div>
+			</div>
+
+			<!-- Length target -->
+			<div>
+				<label class="flex items-center gap-2 cursor-pointer mb-2">
+					<input type="checkbox" class="accent-primary" v-model="form.preserveLength" />
+					<span class="text-xs font-medium text-zinc-700 dark:text-zinc-300">
+						No length target — preserve the full runtime
+					</span>
+				</label>
+				<div v-if="!form.preserveLength" class="flex items-center gap-2">
+					<input type="number" min="5" step="5" v-model.number="form.targetDurationSec"
+						class="w-28 px-3 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 bg-white dark:bg-zinc-900 text-sm font-mono input-focus-ring" />
+					<span class="text-xs text-zinc-500">seconds target</span>
+				</div>
+			</div>
+
+			<div>
+				<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">System prompt *</label>
+				<TextArea v-model="form.systemPrompt" :rows="7"
+					placeholder="You are a … editor. Keep …, remove …, prefer …" />
+				<p class="mt-1 text-[10px] text-zinc-400 leading-snug">
+					This text drives the AI's editing style. Phrase it positively (do-this), not negatively.
+				</p>
+			</div>
+
+			<!-- Live summary -->
+			<p class="text-[11px] text-zinc-500 dark:text-zinc-400 italic border-l-2 border-primary/40 pl-2">
+				This persona will {{ form.preserveLength ? 'preserve the full runtime' : `cut to ~${form.targetDurationSec || 60}s` }},
+				{{ form.pacing }} pacing{{ form.tone ? `, ${form.tone} tone` : '' }}.
+			</p>
+		</div>
+
+		<template #footer>
+			<div class="flex items-center justify-between w-full">
+				<button v-if="isEdit"
+					class="px-3 py-2 rounded-xl text-xs font-bold text-red-500 hover:bg-red-500/10 transition"
+					@click="onDelete">
+					Delete
+				</button>
+				<div v-else></div>
+				<div class="flex gap-2">
+					<button
+						class="px-4 py-2 rounded-xl border border-zinc-200 dark:border-zinc-700 text-xs font-bold text-zinc-600 dark:text-zinc-300 hover:bg-zinc-100 dark:hover:bg-zinc-800 transition"
+						@click="close">
+						Cancel
+					</button>
+					<button
+						class="px-4 py-2 rounded-xl bg-primary text-white text-xs font-bold shadow-md shadow-primary/20 hover:bg-primary-dark transition disabled:opacity-50 disabled:cursor-not-allowed"
+						:disabled="!canSave" @click="save">
+						Save persona
+					</button>
+				</div>
+			</div>
+		</template>
+	</Modal>
+</template>
+
+<script setup lang="ts">
+import { computed, reactive, ref, watch } from 'vue'
+import { Modal } from 'pilotui/complex'
+import { Input, TextArea } from 'pilotui/form'
+import type { EditorPersona } from '@shared/types'
+import { useEditorStore } from '../../stores/editorStore'
+
+const props = defineProps<{
+	modelValue: boolean
+	/** Existing persona (edit/clone-prefill) or null (blank create). */
+	persona: EditorPersona | null
+}>()
+
+const emit = defineEmits<{
+	(e: 'update:modelValue', value: boolean): void
+	(e: 'saved', persona: EditorPersona): void
+}>()
+
+const store = useEditorStore()
+
+const editingId = ref<string | null>(null)
+
+const form = reactive({
+	icon: '🎬',
+	name: '',
+	description: '',
+	mode: 'longform' as 'longform' | 'summarize',
+	tone: '',
+	pacing: 'balanced' as 'tight' | 'balanced' | 'relaxed',
+	preserveLength: true,
+	targetDurationSec: 60,
+	systemPrompt: ''
+})
+
+// isEdit = editing an EXISTING user persona (has id already in the library)
+const isEdit = computed(() =>
+	!!editingId.value && store.personas.some((p) => p.id === editingId.value && !p.builtin)
+)
+
+const canSave = computed(() => form.name.trim().length > 0 && form.systemPrompt.trim().length > 0)
+
+watch(() => props.modelValue, (open) => {
+	if (!open) return
+	const p = props.persona
+	editingId.value = p?.id || null
+	form.icon = p?.icon || '🎬'
+	form.name = p?.name || ''
+	form.description = p?.description || ''
+	form.mode = p?.mode || 'longform'
+	form.tone = p?.tone || ''
+	form.pacing = p?.defaults?.pacing || 'balanced'
+	form.preserveLength = p ? (p.defaults?.targetDurationSec == null) : true
+	form.targetDurationSec = p?.defaults?.targetDurationSec ?? 60
+	form.systemPrompt = p?.systemPrompt || ''
+})
+
+const close = () => emit('update:modelValue', false)
+
+const save = async () => {
+	if (!canSave.value) return
+	const persona: EditorPersona = {
+		id: editingId.value || ((crypto as any).randomUUID ? crypto.randomUUID() : `persona-${Date.now()}`),
+		icon: form.icon || '🎬',
+		name: form.name.trim(),
+		description: form.description.trim(),
+		mode: form.mode,
+		tone: form.tone.trim() || undefined,
+		builtin: false,
+		defaults: {
+			targetDurationSec: form.preserveLength ? null : Math.max(5, form.targetDurationSec || 60),
+			pacing: form.pacing
+		},
+		systemPrompt: form.systemPrompt.trim(),
+		featureSets: []
+	}
+	await store.savePersona(persona)
+	emit('saved', persona)
+	close()
+}
+
+const onDelete = async () => {
+	if (!editingId.value) return
+	const confirmed = await (window as any).api.showConfirmation({
+		title: 'Delete persona',
+		message: 'Delete this persona from your library?',
+		buttons: ['Cancel', 'Delete']
+	})
+	if (!confirmed || confirmed.response !== 1) return
+	await store.deletePersona(editingId.value)
+	close()
+}
+</script>
diff --git a/src/renderer/src/editor/components/PersonaPicker.vue b/src/renderer/src/editor/components/PersonaPicker.vue
new file mode 100644
index 0000000..b85bba2
--- /dev/null
+++ b/src/renderer/src/editor/components/PersonaPicker.vue
@@ -0,0 +1,136 @@
+<template>
+	<div class="relative" ref="rootRef">
+		<!-- Trigger: quiet text-level control, not a boxed button -->
+		<button
+			class="shrink-0 flex items-center gap-1 px-1 py-0.5 rounded-md text-zinc-500 hover:text-primary transition group/persona"
+			title="Switch persona"
+			@click="open = !open">
+			<span class="text-[11px] leading-none">{{ store.activePersona?.icon || '🎬' }}</span>
+			<span class="text-[9px] font-bold uppercase tracking-widest max-w-[100px] truncate">
+				{{ store.activePersona?.name || 'Persona' }}
+			</span>
+			<span class="iconify tabler--chevron-up w-2.5 h-2.5 opacity-50 group-hover/persona:opacity-100 transition-transform" :class="{ 'rotate-180': open }"></span>
+		</button>
+
+		<!-- Popover -->
+		<div v-if="open"
+			class="absolute bottom-full left-0 mb-2 w-72 max-h-96 overflow-y-auto custom-scrollbar rounded-2xl border border-zinc-200 dark:border-zinc-800 bg-white/95 dark:bg-zinc-900/95 backdrop-blur-xl shadow-premium z-50 py-2 origin-bottom animate-menu">
+			<template v-for="group in groups" :key="group.key">
+				<div v-if="group.items.length" class="px-3 pt-2 pb-1">
+					<span class="text-[9px] font-bold uppercase tracking-widest text-zinc-400">{{ group.label }}</span>
+				</div>
+				<button v-for="persona in group.items" :key="persona.id"
+					class="w-full px-3 py-2 flex items-start gap-2.5 hover:bg-primary/5 transition text-left group/row"
+					@click="pick(persona.id)">
+					<span class="text-base leading-none mt-0.5">{{ persona.icon }}</span>
+					<div class="flex-1 min-w-0">
+						<div class="flex items-center gap-1.5">
+							<span class="text-xs font-bold text-zinc-800 dark:text-zinc-200 truncate">{{ persona.name }}</span>
+							<span v-if="persona.id === store.activePersona?.id" class="iconify tabler--check w-3 h-3 text-primary shrink-0"></span>
+						</div>
+						<p class="text-[10px] text-zinc-500 dark:text-zinc-400 leading-snug line-clamp-2">{{ persona.description }}</p>
+					</div>
+					<!-- Hover actions -->
+					<div class="flex items-center gap-0.5 opacity-0 group-hover/row:opacity-100 transition shrink-0">
+						<span class="w-5 h-5 flex items-center justify-center rounded text-zinc-400 hover:text-primary hover:bg-primary/10"
+							title="Duplicate" @click.stop="duplicate(persona.id)">
+							<span class="iconify tabler--copy w-3 h-3"></span>
+						</span>
+						<template v-if="!persona.builtin">
+							<span class="w-5 h-5 flex items-center justify-center rounded text-zinc-400 hover:text-primary hover:bg-primary/10"
+								title="Edit" @click.stop="edit(persona)">
+								<span class="iconify tabler--pencil w-3 h-3"></span>
+							</span>
+							<span class="w-5 h-5 flex items-center justify-center rounded text-zinc-400 hover:text-red-500 hover:bg-red-500/10"
+								title="Delete" @click.stop="remove(persona.id)">
+								<span class="iconify tabler--trash w-3 h-3"></span>
+							</span>
+						</template>
+					</div>
+				</button>
+			</template>
+
+			<!-- Footer -->
+			<div class="border-t border-zinc-200 dark:border-zinc-800 mt-1 pt-1 px-2">
+				<button
+					class="w-full px-2 py-2 rounded-xl flex items-center gap-2 text-xs font-bold text-primary hover:bg-primary/10 transition"
+					@click="createNew">
+					<span class="iconify tabler--plus w-3.5 h-3.5"></span>
+					New persona
+				</button>
+			</div>
+		</div>
+
+		<PersonaEditorModal v-model="editorOpen" :persona="editing" @saved="onSaved" />
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, onUnmounted, ref } from 'vue'
+import type { EditorPersona } from '@shared/types'
+import { useEditorStore } from '../../stores/editorStore'
+import PersonaEditorModal from './PersonaEditorModal.vue'
+
+const store = useEditorStore()
+
+const open = ref(false)
+const editorOpen = ref(false)
+const editing = ref<EditorPersona | null>(null)
+const rootRef = ref<HTMLElement | null>(null)
+
+const groups = computed(() => [
+	{ key: 'longform', label: 'Long-form', items: store.personasByMode.longform },
+	{ key: 'summarize', label: 'Summarize', items: store.personasByMode.summarize },
+	{ key: 'custom', label: 'Custom', items: store.personasByMode.custom }
+])
+
+const pick = (id: string) => {
+	store.setActivePersona(id)
+	open.value = false
+}
+
+const duplicate = (id: string) => {
+	const clone = store.clonePersona(id)
+	if (clone) {
+		editing.value = clone
+		editorOpen.value = true
+		open.value = false
+	}
+}
+
+const edit = (persona: EditorPersona) => {
+	editing.value = JSON.parse(JSON.stringify(persona))
+	editorOpen.value = true
+	open.value = false
+}
+
+const remove = async (id: string) => {
+	await store.deletePersona(id)
+}
+
+const createNew = () => {
+	editing.value = null
+	editorOpen.value = true
+	open.value = false
+}
+
+const onSaved = (persona: EditorPersona) => {
+	store.setActivePersona(persona.id)
+}
+
+// Close on outside click / Escape
+const onDocClick = (e: MouseEvent) => {
+	if (open.value && rootRef.value && !rootRef.value.contains(e.target as Node)) open.value = false
+}
+const onKey = (e: KeyboardEvent) => {
+	if (e.key === 'Escape') open.value = false
+}
+onMounted(() => {
+	document.addEventListener('click', onDocClick)
+	document.addEventListener('keydown', onKey)
+})
+onUnmounted(() => {
+	document.removeEventListener('click', onDocClick)
+	document.removeEventListener('keydown', onKey)
+})
+</script>
diff --git a/src/renderer/src/editor/components/PreviewMonitor.vue b/src/renderer/src/editor/components/PreviewMonitor.vue
new file mode 100644
index 0000000..05efab2
--- /dev/null
+++ b/src/renderer/src/editor/components/PreviewMonitor.vue
@@ -0,0 +1,198 @@
+<template>
+	<div class="glass-card rounded-2xl flex flex-col min-h-0 overflow-hidden">
+		<!-- Mode switch -->
+		<div class="px-3 pt-2 pb-1 flex items-center justify-between shrink-0">
+			<div class="flex items-center bg-zinc-100/80 dark:bg-zinc-900/80 rounded-lg p-0.5 border border-zinc-200 dark:border-zinc-800">
+				<button v-for="m in (['source', 'timeline'] as const)" :key="m"
+					class="px-2 py-0.5 rounded-md text-[9px] font-bold uppercase tracking-widest transition"
+					:class="mode === m
+						? 'bg-primary text-white shadow-md shadow-primary/20 ring-1 ring-primary/20'
+						: 'text-zinc-500 hover:text-zinc-700 dark:hover:text-zinc-300'"
+					@click="mode = m">
+					{{ m }}
+				</button>
+			</div>
+			<span v-if="mode === 'timeline' && edl.currentSegmentId.value" class="text-[9px] font-mono text-zinc-400 truncate max-w-[50%]">
+				{{ activeSegmentLabel }}
+			</span>
+		</div>
+
+		<!-- ============ SOURCE MODE ============ -->
+		<template v-if="mode === 'source'">
+			<div v-if="!sourceSrc" class="flex-1 flex flex-col items-center justify-center gap-3 bg-zinc-950/[0.03] dark:bg-black/40">
+				<div class="w-14 h-14 rounded-2xl bg-zinc-500/10 flex items-center justify-center text-zinc-400">
+					<span class="iconify tabler--player-play w-7 h-7"></span>
+				</div>
+				<p class="text-xs text-zinc-500 dark:text-zinc-400 font-medium">Import or select media to preview</p>
+			</div>
+			<template v-else>
+				<div class="flex-1 min-h-0 bg-black flex items-center justify-center relative">
+					<video ref="sourceVideoRef" :src="sourceSrc" class="max-h-full max-w-full" preload="metadata"
+						@loadedmetadata="onSourceLoaded" @timeupdate="onSourceTimeUpdate"
+						@play="sourcePlaying = true" @pause="sourcePlaying = false"></video>
+					<div v-if="activeClip"
+						class="absolute top-2 left-2 px-2 py-1 rounded-lg bg-black/60 backdrop-blur-sm text-[10px] font-mono text-white/90">
+						Piece #{{ activeClip.index }} · {{ format(activeClip.in) }}–{{ format(activeClip.out) }}
+					</div>
+				</div>
+				<div class="px-4 py-2.5 flex items-center gap-3 border-t border-zinc-200 dark:border-zinc-800 shrink-0">
+					<button
+						class="w-8 h-8 rounded-full bg-primary text-white flex items-center justify-center shadow-md shadow-primary/20 hover:bg-primary-dark transition active:scale-95"
+						@click="toggleSourcePlay">
+						<span :class="sourcePlaying ? 'iconify tabler--player-pause-filled' : 'iconify tabler--player-play-filled'"
+							class="w-3.5 h-3.5"></span>
+					</button>
+					<span class="text-[11px] font-mono text-zinc-600 dark:text-zinc-300">
+						{{ format(sourceTime) }} <span class="text-zinc-400">/ {{ format(sourceDuration) }}</span>
+					</span>
+					<input type="range" class="flex-1 accent-primary h-1 cursor-pointer" min="0" :max="sourceDuration || 0"
+						step="0.05" :value="sourceTime" @input="onSourceScrub" />
+				</div>
+			</template>
+		</template>
+
+		<!-- ============ TIMELINE MODE (EDL) ============ -->
+		<template v-else>
+			<div v-if="!edl.hasContent.value"
+				class="flex-1 flex flex-col items-center justify-center gap-3 bg-zinc-950/[0.03] dark:bg-black/40">
+				<div class="w-14 h-14 rounded-2xl bg-zinc-500/10 flex items-center justify-center text-zinc-400">
+					<span class="iconify tabler--layout-list w-7 h-7"></span>
+				</div>
+				<p class="text-xs text-zinc-500 dark:text-zinc-400 font-medium">Timeline is empty — drag pieces onto a track</p>
+			</div>
+			<template v-else>
+				<div class="flex-1 min-h-0 bg-black relative">
+					<video ref="videoARef" class="absolute inset-0 w-full h-full object-contain transition-opacity"
+						:class="edl.activeIsA.value && !edl.inGap.value ? 'opacity-100' : 'opacity-0'"
+						preload="auto"></video>
+					<video ref="videoBRef" class="absolute inset-0 w-full h-full object-contain transition-opacity"
+						:class="!edl.activeIsA.value && !edl.inGap.value ? 'opacity-100' : 'opacity-0'"
+						preload="auto"></video>
+					<!-- Audio tracks play through an element pool in the composable
+					     (one per track), heard in parallel with the video. -->
+					<div v-if="edl.inGap.value"
+						class="absolute inset-0 flex flex-col items-center justify-center gap-2 pointer-events-none">
+						<template v-if="edl.audioActive.value">
+							<span class="iconify tabler--music w-6 h-6 text-white/40"></span>
+							<span class="text-[10px] font-mono text-white/30 uppercase tracking-widest">audio only</span>
+						</template>
+						<span v-else class="text-[10px] font-mono text-white/30 uppercase tracking-widest">gap</span>
+					</div>
+				</div>
+				<div class="px-4 py-2.5 flex items-center gap-3 border-t border-zinc-200 dark:border-zinc-800 shrink-0">
+					<button
+						class="w-8 h-8 rounded-full bg-primary text-white flex items-center justify-center shadow-md shadow-primary/20 hover:bg-primary-dark transition active:scale-95"
+						@click="store.isPlaying = !store.isPlaying">
+						<span :class="store.isPlaying ? 'iconify tabler--player-pause-filled' : 'iconify tabler--player-play-filled'"
+							class="w-3.5 h-3.5"></span>
+					</button>
+					<span class="text-[11px] font-mono text-zinc-600 dark:text-zinc-300">
+						{{ format(store.playheadSec) }} <span class="text-zinc-400">/ {{ format(store.contentEnd) }}</span>
+					</span>
+					<input type="range" class="flex-1 accent-primary h-1 cursor-pointer" min="0"
+						:max="store.contentEnd || 0" step="0.05" :value="store.playheadSec"
+						@input="onTimelineScrub" />
+				</div>
+			</template>
+		</template>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, ref, watch } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+import { useEdlPlayback } from '../composables/useEdlPlayback'
+
+const store = useEditorStore()
+
+const mode = ref<'source' | 'timeline'>('source')
+
+// ===== EDL (timeline) mode =====
+const videoARef = ref<HTMLVideoElement | null>(null)
+const videoBRef = ref<HTMLVideoElement | null>(null)
+const edl = useEdlPlayback(videoARef, videoBRef)
+
+onMounted(() => edl.start())
+
+const activeSegmentLabel = computed(() => {
+	const item = store.doc?.timeline.find((i) => i.id === edl.currentSegmentId.value)
+	return item?.label || ''
+})
+
+const onTimelineScrub = (event: Event) => {
+	store.seekTo(parseFloat((event.target as HTMLInputElement).value))
+}
+
+// Auto-switch: tray clip selection → source; timeline item selection / play → timeline
+watch(() => store.selectedClipId, (id) => { if (id) mode.value = 'source' })
+watch(() => store.selectedItemIds, (ids) => { if (ids.length) mode.value = 'timeline' })
+watch(() => store.isPlaying, (playing) => { if (playing) mode.value = 'timeline' })
+
+// ===== Source mode (single asset / piece preview, from M1) =====
+const sourceVideoRef = ref<HTMLVideoElement | null>(null)
+const sourcePlaying = ref(false)
+const sourceTime = ref(0)
+const sourceDuration = ref(0)
+
+const activeClip = computed(() => store.selectedClip)
+
+const sourceSrc = computed(() => {
+	const asset = activeClip.value
+		? store.assets.find((a) => a.id === activeClip.value!.sourceAssetId)
+		: store.selectedAsset
+	if (!asset) return null
+	const path = asset.proxyPath || asset.originalPath
+	return path ? `media://${path}` : null
+})
+
+const format = (seconds: number) => {
+	const m = Math.floor(seconds / 60)
+	const s = Math.floor(seconds % 60)
+	const ms = Math.floor((seconds % 1) * 10)
+	return `${m}:${String(s).padStart(2, '0')}.${ms}`
+}
+
+const onSourceLoaded = () => {
+	const video = sourceVideoRef.value
+	if (!video) return
+	sourceDuration.value = video.duration || 0
+	if (activeClip.value) video.currentTime = activeClip.value.in
+}
+
+const onSourceTimeUpdate = () => {
+	const video = sourceVideoRef.value
+	if (!video) return
+	sourceTime.value = video.currentTime
+	if (activeClip.value && sourcePlaying.value && video.currentTime >= activeClip.value.out) {
+		video.pause()
+	}
+}
+
+const onSourceScrub = (event: Event) => {
+	const video = sourceVideoRef.value
+	if (!video) return
+	const value = parseFloat((event.target as HTMLInputElement).value)
+	video.currentTime = value
+	sourceTime.value = value
+}
+
+const toggleSourcePlay = () => {
+	const video = sourceVideoRef.value
+	if (!video) return
+	if (video.paused) {
+		if (activeClip.value && video.currentTime >= activeClip.value.out - 0.05) {
+			video.currentTime = activeClip.value.in
+		}
+		video.play()
+	} else {
+		video.pause()
+	}
+}
+
+watch(activeClip, (clip) => {
+	const video = sourceVideoRef.value
+	if (!video || !clip) return
+	video.currentTime = clip.in
+	sourceTime.value = clip.in
+})
+</script>
diff --git a/src/renderer/src/editor/components/PromptBar.vue b/src/renderer/src/editor/components/PromptBar.vue
new file mode 100644
index 0000000..66eee9e
--- /dev/null
+++ b/src/renderer/src/editor/components/PromptBar.vue
@@ -0,0 +1,144 @@
+<template>
+	<div class="shrink-0">
+		<!-- Inline error -->
+		<div v-if="store.promptError"
+			class="mb-2 px-3 py-2 rounded-xl bg-red-500/10 border border-red-500/20 flex items-center justify-between gap-2 animate-fade-in-up">
+			<p class="text-[11px] font-medium text-red-500 leading-snug">{{ store.promptError }}</p>
+			<button v-if="lastPrompt"
+				class="px-2 py-1 rounded-lg bg-red-500/10 text-red-500 text-[10px] font-bold uppercase tracking-widest hover:bg-red-500/20 transition shrink-0"
+				@click="retry">
+				Retry
+			</button>
+		</div>
+
+		<!-- Flat input zone: the panel's border-t is the only frame. -->
+		<div>
+			<textarea ref="inputRef" v-model="text" rows="1"
+				class="w-full bg-transparent resize-none outline-none text-sm text-zinc-800 dark:text-zinc-200 placeholder-zinc-400 max-h-24 custom-scrollbar py-1"
+				:placeholder="placeholder" :disabled="inputDisabled"
+				@input="autoGrow" @keydown.enter.exact.prevent="submit"></textarea>
+
+			<!-- Meta row: quiet text controls left, send right -->
+			<div class="flex items-center gap-1 mt-0.5">
+				<PersonaPicker />
+
+				<span class="text-zinc-300 dark:text-zinc-700 text-[9px]">·</span>
+
+				<!-- Scope: text-level control — owns the flexible space so it
+				     truncates with clearance before the send button -->
+				<div class="relative flex-1 min-w-0" ref="scopeRef">
+					<button v-if="store.scopePreview"
+						class="max-w-full flex items-center gap-1 px-1 py-0.5 rounded-md text-zinc-500 hover:text-secondary transition min-w-0"
+						:title="'What the AI can see — click to change'"
+						@click="scopeMenuOpen = !scopeMenuOpen">
+						<span class="iconify tabler--focus-2 w-2.5 h-2.5 text-secondary/70 shrink-0"></span>
+						<span class="text-[9px] font-bold uppercase tracking-widest truncate">
+							{{ store.scopePreview.label }}
+						</span>
+					</button>
+					<div v-if="scopeMenuOpen"
+						class="absolute bottom-full left-0 mb-2 w-48 rounded-xl border border-zinc-200 dark:border-zinc-800 bg-white/95 dark:bg-zinc-900/95 backdrop-blur-xl shadow-premium z-50 py-1 origin-bottom animate-menu">
+						<button v-for="option in scopeOptions" :key="option.value"
+							class="w-full px-3 py-1.5 flex items-center justify-between text-left hover:bg-primary/5 transition"
+							@click="setScope(option.value)">
+							<span class="text-[11px] font-medium text-zinc-700 dark:text-zinc-300">{{ option.label }}</span>
+							<span v-if="store.scopeWiden === option.value" class="iconify tabler--check w-3 h-3 text-primary"></span>
+						</button>
+					</div>
+				</div>
+
+				<!-- Send / Stop -->
+				<button
+					class="ml-2 shrink-0 w-6 h-6 rounded-full flex items-center justify-center transition active:scale-95"
+					:class="store.promptRunning
+						? 'bg-red-500 text-white hover:bg-red-600'
+						: canSend
+							? 'bg-primary text-white hover:bg-primary-dark'
+							: 'text-zinc-300 dark:text-zinc-600 cursor-not-allowed'"
+					:title="store.promptRunning ? 'Stop' : 'Send (Enter)'"
+					@click="store.promptRunning ? store.abortPrompt() : submit()">
+					<span v-if="store.promptRunning" class="iconify tabler--player-stop-filled w-2.5 h-2.5"></span>
+					<span v-else class="iconify tabler--send w-3 h-3"></span>
+				</button>
+			</div>
+		</div>
+
+		<!-- Running status -->
+		<div v-if="store.promptRunning" class="mt-1.5 flex items-center gap-2 px-2">
+			<div class="w-3 h-3 rounded-full border-2 border-primary border-t-transparent animate-spin"></div>
+			<span class="text-[10px] font-medium text-zinc-500">
+				{{ store.activePersona?.name || 'AI' }} is working on your edit…
+			</span>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, onUnmounted, ref } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+import PersonaPicker from './PersonaPicker.vue'
+
+const store = useEditorStore()
+
+const text = ref('')
+const lastPrompt = ref('')
+const scopeMenuOpen = ref(false)
+const inputRef = ref<HTMLTextAreaElement | null>(null)
+const scopeRef = ref<HTMLElement | null>(null)
+
+// Chat is inert until media is imported AND has finished preprocessing —
+// the AI needs pieces/transcript to reason about the footage.
+const inputDisabled = computed(() => store.promptRunning || !store.hasReadyMedia)
+
+// Keep placeholders short — the narrow rail clips a single-row textarea, and
+// the chat empty-state already carries the full guidance.
+const placeholder = computed(() => {
+	if (store.isEmpty) return 'Import media to start…'
+	if (store.mediaProcessing) return 'Preparing media…'
+	if (!store.hasReadyMedia) return 'Media not ready yet…'
+	return `Message ${store.activePersona?.name || 'your editor'}…`
+})
+
+const canSend = computed(() => text.value.trim().length > 0 && !inputDisabled.value)
+
+const scopeOptions = computed(() => [
+	{
+		value: 'auto' as const,
+		label: store.selectedItemIds.length ? `Auto (selection · ${store.selectedItemIds.length})` : 'Auto'
+	},
+	{ value: 'chapter' as const, label: 'Current chapter' },
+	{ value: 'full' as const, label: 'Whole timeline' }
+])
+
+const setScope = (value: 'auto' | 'chapter' | 'full') => {
+	store.scopeWiden = value
+	scopeMenuOpen.value = false
+}
+
+const autoGrow = () => {
+	const el = inputRef.value
+	if (!el) return
+	el.style.height = 'auto'
+	el.style.height = `${Math.min(el.scrollHeight, 96)}px`
+}
+
+const submit = () => {
+	if (!canSend.value) return
+	lastPrompt.value = text.value.trim()
+	store.runPrompt(lastPrompt.value)
+	text.value = ''
+	autoGrow()
+}
+
+const retry = () => {
+	if (lastPrompt.value) store.runPrompt(lastPrompt.value)
+}
+
+const onDocClick = (e: MouseEvent) => {
+	if (scopeMenuOpen.value && scopeRef.value && !scopeRef.value.contains(e.target as Node)) {
+		scopeMenuOpen.value = false
+	}
+}
+onMounted(() => document.addEventListener('click', onDocClick))
+onUnmounted(() => document.removeEventListener('click', onDocClick))
+</script>
diff --git a/src/renderer/src/editor/components/RevisionGraphModal.vue b/src/renderer/src/editor/components/RevisionGraphModal.vue
new file mode 100644
index 0000000..88b516d
--- /dev/null
+++ b/src/renderer/src/editor/components/RevisionGraphModal.vue
@@ -0,0 +1,100 @@
+<template>
+	<Modal :model-value="modelValue" title="Revision graph" size="xl"
+		@update:model-value="$emit('update:modelValue', $event)">
+		<div class="h-[70vh] rounded-xl overflow-hidden border border-zinc-200 dark:border-zinc-800 relative">
+			<VueFlow :nodes="nodes" :edges="edges" :min-zoom="0.2" :max-zoom="2"
+				:nodes-draggable="false" :nodes-connectable="false" :edges-updatable="false"
+				class="revision-flow" @pane-ready="onPaneReady">
+				<Background pattern-color="#888" :gap="24" />
+				<Controls :show-interactive="false" />
+				<template #node-revision="props">
+					<RevisionGraphNode v-bind="props" />
+				</template>
+			</VueFlow>
+			<p class="absolute bottom-2 left-1/2 -translate-x-1/2 text-[10px] text-zinc-400 bg-white/70 dark:bg-zinc-900/70 backdrop-blur px-2 py-1 rounded-lg pointer-events-none">
+				Click a revision to switch — branch by editing or prompting from there
+			</p>
+		</div>
+	</Modal>
+</template>
+
+<script setup lang="ts">
+import { computed, watch } from 'vue'
+import { VueFlow, useVueFlow, type Edge, type Node } from '@vue-flow/core'
+import { Background } from '@vue-flow/background'
+import { Controls } from '@vue-flow/controls'
+import { Modal } from 'pilotui/complex'
+import type { EditorRevision } from '@shared/types'
+import { useEditorStore } from '../../stores/editorStore'
+import RevisionGraphNode from './RevisionGraphNode.vue'
+
+const props = defineProps<{ modelValue: boolean }>()
+defineEmits<{ (e: 'update:modelValue', value: boolean): void }>()
+
+const store = useEditorStore()
+const { fitView } = useVueFlow()
+
+const COL_W = 280   // horizontal spread per branch column
+const ROW_H = 170   // vertical distance per generation
+
+/**
+ * Tidy tree layout: every node sits at (column · COL_W, depth · ROW_H).
+ * A node's column = its FIRST child's column (main line stays vertical);
+ * leaves claim the next free column, so sibling branches fan right without
+ * collisions — the same visual convention as the chat graph.
+ */
+const layout = computed(() => {
+	const positions = new Map<string, { x: number; y: number }>()
+	let nextColumn = 0
+
+	const assign = (rev: EditorRevision, depth: number): number => {
+		const children = store.revisionChildren.get(rev.id) || []
+		let column: number
+		if (children.length === 0) {
+			column = nextColumn++
+		} else {
+			const childColumns = children.map((c) => assign(c, depth + 1))
+			column = childColumns[0]
+		}
+		positions.set(rev.id, { x: column * COL_W, y: depth * ROW_H })
+		return column
+	}
+
+	for (const root of store.revisionChildren.get(null) || []) assign(root, 0)
+	return positions
+})
+
+const nodes = computed<Node[]>(() =>
+	store.revisions.map((rev) => ({
+		id: rev.id,
+		type: 'revision',
+		position: layout.value.get(rev.id) || { x: 0, y: 0 },
+		data: { revision: rev },
+		draggable: false
+	}))
+)
+
+const edges = computed<Edge[]>(() =>
+	store.revisions
+		.filter((rev) => rev.parentId !== null)
+		.map((rev) => ({
+			id: `e-${rev.parentId}-${rev.id}`,
+			source: rev.parentId!,
+			target: rev.id,
+			animated: false
+		}))
+)
+
+const onPaneReady = () => fitView({ padding: 0.2 })
+
+watch(() => props.modelValue, (open) => {
+	if (open) setTimeout(() => fitView({ padding: 0.2 }), 50)
+})
+</script>
+
+<style scoped>
+.revision-flow {
+	width: 100%;
+	height: 100%;
+}
+</style>
diff --git a/src/renderer/src/editor/components/RevisionGraphNode.vue b/src/renderer/src/editor/components/RevisionGraphNode.vue
new file mode 100644
index 0000000..0c34984
--- /dev/null
+++ b/src/renderer/src/editor/components/RevisionGraphNode.vue
@@ -0,0 +1,61 @@
+<template>
+	<div class="w-[220px] rounded-2xl border-2 bg-white/90 dark:bg-zinc-900/90 backdrop-blur-xl shadow-premium p-2.5 cursor-pointer transition"
+		:class="isCurrent
+			? 'border-primary ring-2 ring-primary/30'
+			: 'border-zinc-200 dark:border-zinc-700 hover:border-primary/40'"
+		@click="onClick">
+		<!-- Header row -->
+		<div class="flex items-center gap-1.5 mb-1.5">
+			<span class="text-[10px] font-bold text-primary font-mono">V{{ revision.seq }}</span>
+			<span class="leading-none">
+				<span v-if="revision.origin === 'ai'" class="text-xs">{{ personaIcon }}</span>
+				<span v-else-if="revision.origin === 'manual'" class="iconify tabler--bookmark w-3 h-3 text-secondary"></span>
+				<span v-else class="iconify tabler--flag w-3 h-3 text-zinc-400"></span>
+			</span>
+			<span class="flex-1 text-[10px] font-bold text-zinc-700 dark:text-zinc-300 truncate">{{ revision.label }}</span>
+			<span v-if="isCurrent" class="iconify tabler--check w-3 h-3 text-primary shrink-0"></span>
+		</div>
+
+		<!-- Thumb strip -->
+		<div class="flex gap-1 h-9 mb-1">
+			<template v-if="thumbs.length">
+				<img v-for="(thumb, i) in thumbs" :key="i" :src="thumb"
+					class="flex-1 min-w-0 h-full object-cover rounded-md" loading="lazy" />
+			</template>
+			<div v-else class="flex-1 h-full rounded-md bg-zinc-200 dark:bg-zinc-800 flex items-center justify-center">
+				<span class="iconify tabler--movie w-3.5 h-3.5 text-zinc-400"></span>
+			</div>
+		</div>
+
+		<p class="text-[9px] text-zinc-400 leading-none">
+			{{ itemCount }} clips · {{ time }}
+		</p>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { EditorRevision } from '@shared/types'
+import { useEditorStore } from '../../stores/editorStore'
+import { relativeTime, revisionThumbs } from '../utils/revisionThumbs'
+
+const props = defineProps<{
+	data: { revision: EditorRevision }
+}>()
+
+const store = useEditorStore()
+
+const revision = computed(() => props.data.revision)
+const isCurrent = computed(() => store.doc?.currentRevisionId === revision.value.id)
+const thumbs = computed(() => revisionThumbs(revision.value, store.doc, 3))
+const itemCount = computed(() => revision.value.snapshot.timeline.length)
+const time = computed(() => relativeTime(revision.value.createdAt))
+
+const personaIcon = computed(() =>
+	store.personas.find((p) => p.id === revision.value.personaId)?.icon || '✨'
+)
+
+const onClick = () => {
+	if (!isCurrent.value) store.switchRevision(revision.value.id)
+}
+</script>
diff --git a/src/renderer/src/editor/components/RevisionListItem.vue b/src/renderer/src/editor/components/RevisionListItem.vue
new file mode 100644
index 0000000..ec04251
--- /dev/null
+++ b/src/renderer/src/editor/components/RevisionListItem.vue
@@ -0,0 +1,75 @@
+<template>
+	<div class="group flex items-center gap-2 px-2 py-1.5 rounded-xl transition mb-1"
+		:class="[
+			isCurrent
+				? 'ring-1 ring-primary/40 bg-primary/5 dark:bg-primary/10'
+				: 'hover:bg-zinc-100/60 dark:hover:bg-zinc-800/40',
+			disabled ? 'opacity-50 pointer-events-none' : 'cursor-pointer'
+		]"
+		:style="{ paddingLeft: `${8 + Math.min(depth, 6) * 12}px` }"
+		:title="disabled ? 'Wait for the AI edit to finish' : (isCurrent ? 'Current revision' : 'Switch to this revision')"
+		@click="store.switchRevision(revision.id)">
+
+		<!-- Thumb -->
+		<div class="w-10 h-6 rounded-md overflow-hidden bg-zinc-200 dark:bg-zinc-800 shrink-0 flex items-center justify-center">
+			<img v-if="thumb" :src="thumb" class="w-full h-full object-cover" loading="lazy" />
+			<span v-else class="iconify tabler--movie w-3 h-3 text-zinc-400"></span>
+		</div>
+
+		<!-- V pill + origin icon -->
+		<span class="text-[10px] font-bold text-primary font-mono shrink-0">V{{ revision.seq }}</span>
+		<span class="shrink-0 leading-none" :title="originTitle">
+			<span v-if="revision.origin === 'ai'" class="text-xs">{{ personaIcon }}</span>
+			<span v-else-if="revision.origin === 'manual'" class="iconify tabler--bookmark w-3 h-3 text-secondary"></span>
+			<span v-else class="iconify tabler--flag w-3 h-3 text-zinc-400"></span>
+		</span>
+
+		<!-- Label + time -->
+		<div class="flex-1 min-w-0">
+			<p class="text-[11px] font-medium text-zinc-700 dark:text-zinc-300 truncate leading-tight">
+				{{ revision.label }}
+				<span v-if="isCurrent && store.revisionDirty" class="text-amber-500" title="Unsaved changes since this revision">*</span>
+			</p>
+			<p class="text-[9px] text-zinc-400 leading-tight">{{ time }}</p>
+		</div>
+
+		<!-- Delete subtree (root undeletable) -->
+		<button v-if="revision.parentId !== null"
+			class="w-5 h-5 flex items-center justify-center rounded text-zinc-400 opacity-0 group-hover:opacity-100 hover:text-red-500 hover:bg-red-500/10 transition shrink-0"
+			title="Delete this revision and its descendants"
+			@click.stop="store.deleteRevisionSubtree(revision.id)">
+			<span class="iconify tabler--trash w-3 h-3"></span>
+		</button>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { EditorRevision } from '@shared/types'
+import { useEditorStore } from '../../stores/editorStore'
+import { relativeTime, revisionThumbs } from '../utils/revisionThumbs'
+
+const props = defineProps<{
+	revision: EditorRevision
+	depth: number
+}>()
+
+const store = useEditorStore()
+
+const isCurrent = computed(() => store.doc?.currentRevisionId === props.revision.id)
+const disabled = computed(() => store.promptRunning)
+const thumb = computed(() => revisionThumbs(props.revision, store.doc, 1)[0] || null)
+const time = computed(() => relativeTime(props.revision.createdAt))
+
+const personaIcon = computed(() =>
+	store.personas.find((p) => p.id === props.revision.personaId)?.icon || '✨'
+)
+
+const originTitle = computed(() => {
+	switch (props.revision.origin) {
+		case 'ai': return 'AI edit'
+		case 'manual': return 'Manual checkpoint'
+		default: return 'Original'
+	}
+})
+</script>
diff --git a/src/renderer/src/editor/components/RevisionsPanel.vue b/src/renderer/src/editor/components/RevisionsPanel.vue
new file mode 100644
index 0000000..0d20482
--- /dev/null
+++ b/src/renderer/src/editor/components/RevisionsPanel.vue
@@ -0,0 +1,64 @@
+<template>
+	<div class="glass-card rounded-2xl flex flex-col min-h-0 overflow-hidden">
+		<!-- Header -->
+		<div class="px-4 pt-4 pb-2 flex items-center justify-between shrink-0">
+			<span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500">Revisions</span>
+			<div class="flex items-center gap-1">
+				<SaveRevisionButton />
+				<button
+					class="w-7 h-7 flex items-center justify-center rounded-lg text-zinc-500 hover:text-primary hover:bg-primary/10 transition active:scale-95"
+					title="View as graph" :disabled="store.revisions.length === 0"
+					@click="showGraph = true">
+					<span class="iconify tabler--sitemap w-4 h-4"></span>
+				</button>
+			</div>
+		</div>
+
+		<!-- Tree list -->
+		<div class="flex-1 min-h-0 overflow-y-auto custom-scrollbar px-2 pb-3">
+			<!-- Empty state -->
+			<div v-if="store.revisions.length === 0"
+				class="h-full flex flex-col items-center justify-center text-center gap-3 py-8">
+				<div class="w-12 h-12 rounded-2xl bg-secondary/10 flex items-center justify-center text-secondary">
+					<span class="iconify tabler--bookmark w-6 h-6"></span>
+				</div>
+				<p class="text-xs text-zinc-500 dark:text-zinc-400 leading-relaxed px-4">
+					Save a revision or run an AI edit to start the tree. Every prompt result becomes a
+					revision you can branch from.
+				</p>
+			</div>
+
+			<template v-else>
+				<RevisionListItem v-for="entry in flatTree" :key="entry.revision.id"
+					:revision="entry.revision" :depth="entry.depth" />
+			</template>
+		</div>
+
+		<RevisionGraphModal v-model="showGraph" />
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+import type { EditorRevision } from '@shared/types'
+import { useEditorStore } from '../../stores/editorStore'
+import RevisionListItem from './RevisionListItem.vue'
+import SaveRevisionButton from './SaveRevisionButton.vue'
+import RevisionGraphModal from './RevisionGraphModal.vue'
+
+const store = useEditorStore()
+const showGraph = ref(false)
+
+/** DFS over the revision tree: main line first (createdAt order), depth-indented. */
+const flatTree = computed<{ revision: EditorRevision; depth: number }[]>(() => {
+	const out: { revision: EditorRevision; depth: number }[] = []
+	const walk = (parentId: string | null, depth: number) => {
+		for (const rev of store.revisionChildren.get(parentId) || []) {
+			out.push({ revision: rev, depth })
+			walk(rev.id, depth + 1)
+		}
+	}
+	walk(null, 0)
+	return out
+})
+</script>
diff --git a/src/renderer/src/editor/components/SaveRevisionButton.vue b/src/renderer/src/editor/components/SaveRevisionButton.vue
new file mode 100644
index 0000000..730c20b
--- /dev/null
+++ b/src/renderer/src/editor/components/SaveRevisionButton.vue
@@ -0,0 +1,73 @@
+<template>
+	<div class="relative" ref="rootRef">
+		<button
+			class="w-7 h-7 flex items-center justify-center rounded-lg transition active:scale-95"
+			:class="store.revisionDirty || store.revisions.length === 0
+				? 'text-secondary hover:bg-secondary/10'
+				: 'text-zinc-400 hover:text-zinc-600 dark:hover:text-zinc-300'"
+			title="Save the current timeline as a revision"
+			@click="open = !open">
+			<span class="iconify tabler--bookmark-plus w-4 h-4"></span>
+		</button>
+
+		<!-- Inline popover -->
+		<div v-if="open"
+			class="absolute top-full right-0 mt-2 w-56 rounded-xl border border-zinc-200 dark:border-zinc-800 bg-white/95 dark:bg-zinc-900/95 backdrop-blur-xl shadow-premium z-50 p-3 origin-top animate-menu">
+			<template v-if="cleanNotice">
+				<p class="text-[11px] text-zinc-500 leading-snug">
+					No changes since <span class="font-mono font-bold text-primary">V{{ store.currentRevision?.seq }}</span>.
+				</p>
+			</template>
+			<template v-else>
+				<label class="text-[10px] font-bold uppercase tracking-widest text-zinc-500 block mb-1.5">
+					Save revision
+				</label>
+				<input ref="inputRef" v-model="label" type="text" placeholder="Label (optional)"
+					class="w-full px-2.5 py-1.5 rounded-lg border border-zinc-200 dark:border-zinc-700 bg-white dark:bg-zinc-950 text-xs text-zinc-800 dark:text-zinc-200 input-focus-ring mb-2"
+					@keyup.enter="save" />
+				<button
+					class="w-full px-3 py-1.5 rounded-lg bg-secondary text-white text-xs font-bold shadow-md shadow-secondary/20 hover:opacity-90 transition active:scale-95"
+					@click="save">
+					Save
+				</button>
+			</template>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { nextTick, onMounted, onUnmounted, ref, watch } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+
+const store = useEditorStore()
+
+const open = ref(false)
+const label = ref('')
+const cleanNotice = ref(false)
+const rootRef = ref<HTMLElement | null>(null)
+const inputRef = ref<HTMLInputElement | null>(null)
+
+watch(open, async (isOpen) => {
+	if (isOpen) {
+		cleanNotice.value = store.revisions.length > 0 && !store.revisionDirty
+		label.value = ''
+		await nextTick()
+		inputRef.value?.focus()
+	}
+})
+
+const save = async () => {
+	const result = await store.saveCheckpoint(label.value)
+	if (result === 'clean') {
+		cleanNotice.value = true
+	} else {
+		open.value = false
+	}
+}
+
+const onDocClick = (e: MouseEvent) => {
+	if (open.value && rootRef.value && !rootRef.value.contains(e.target as Node)) open.value = false
+}
+onMounted(() => document.addEventListener('click', onDocClick))
+onUnmounted(() => document.removeEventListener('click', onDocClick))
+</script>
diff --git a/src/renderer/src/editor/components/SilenceFinder.vue b/src/renderer/src/editor/components/SilenceFinder.vue
new file mode 100644
index 0000000..26629a5
--- /dev/null
+++ b/src/renderer/src/editor/components/SilenceFinder.vue
@@ -0,0 +1,94 @@
+<template>
+	<div class="mt-5 pt-4 border-t border-zinc-200/60 dark:border-zinc-700/50">
+		<span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500">Silence finder</span>
+
+		<!-- Detection thresholds -->
+		<div v-if="!compact" class="mt-2 grid grid-cols-2 gap-2">
+			<div>
+				<label class="text-[9px] font-bold uppercase tracking-widest text-zinc-400 block mb-1">
+					Noise floor (dB)
+				</label>
+				<input type="number" min="-60" max="0" step="1" v-model.number="editorStore.silenceNoiseDb"
+					class="w-full px-2 py-1.5 rounded-lg border border-zinc-200 dark:border-zinc-700 bg-white dark:bg-zinc-900 text-xs font-mono text-zinc-800 dark:text-zinc-200 input-focus-ring" />
+			</div>
+			<div>
+				<label class="text-[9px] font-bold uppercase tracking-widest text-zinc-400 block mb-1">
+					Min duration (s)
+				</label>
+				<input type="number" min="0.1" max="10" step="0.1" v-model.number="editorStore.silenceMinDurationSec"
+					class="w-full px-2 py-1.5 rounded-lg border border-zinc-200 dark:border-zinc-700 bg-white dark:bg-zinc-900 text-xs font-mono text-zinc-800 dark:text-zinc-200 input-focus-ring" />
+			</div>
+		</div>
+
+		<button v-if="!compact || !results"
+			class="mt-2 w-full px-3 py-2 rounded-xl border border-primary/40 text-primary text-xs font-bold hover:bg-primary/10 transition active:scale-95 disabled:opacity-50"
+			:disabled="editorStore.silenceScanning" @click="editorStore.scanSilence(assetId)">
+			<span class="iconify tabler--wave-saw-tool w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+			{{ scanLabel }}
+		</button>
+
+		<template v-if="results !== null">
+			<p v-if="results.length === 0" class="mt-2 text-[11px] text-zinc-400">
+				No silent regions found.
+			</p>
+			<template v-else>
+				<div class="mt-2 max-h-40 overflow-y-auto custom-scrollbar rounded-lg border border-zinc-200 dark:border-zinc-700 divide-y divide-zinc-100 dark:divide-zinc-800">
+					<button v-for="(r, i) in results" :key="i"
+						class="w-full flex items-center justify-between gap-2 px-2 py-1.5 text-left hover:bg-primary/5 transition"
+						@click="seekToRegion(r)">
+						<span class="font-mono text-[11px] text-zinc-600 dark:text-zinc-300">{{ formatTime(r.start) }} – {{ formatTime(r.end) }}</span>
+						<span class="font-mono text-[10px] text-zinc-400">{{ (r.end - r.start).toFixed(1) }}s</span>
+					</button>
+				</div>
+				<button
+					class="mt-2 w-full px-3 py-2 rounded-xl bg-primary text-white text-xs font-bold shadow-md shadow-primary/20 hover:bg-primary/90 transition active:scale-95"
+					@click="editorStore.applySilenceRegions(assetId, results)">
+					<span class="iconify tabler--scissors w-3.5 h-3.5 inline-block align-[-2px] mr-1"></span>
+					Ripple-delete {{ results.length }} region{{ results.length === 1 ? '' : 's' }}
+				</button>
+				<p class="mt-1 text-[9px] text-zinc-400 leading-snug">
+					Removes these ranges from this asset's placed clips and closes the gaps. Undoable.
+				</p>
+			</template>
+		</template>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+
+const props = withDefaults(defineProps<{
+	assetId: string
+	/** Compact mode (clip/item inspector): results + apply only, no threshold inputs. */
+	compact?: boolean
+}>(), { compact: false })
+
+const editorStore = useEditorStore()
+
+// Results are shown only when the store's scan belongs to THIS asset, so the
+// panel follows the asset across inspector modes without leaking across assets.
+const results = computed(() =>
+	editorStore.silenceScan?.assetId === props.assetId ? editorStore.silenceScan.regions : null
+)
+
+const scanLabel = computed(() => {
+	if (editorStore.silenceScanning) {
+		const p = editorStore.silenceScanPercent
+		return p !== null && p > 0 ? `Scanning… ${p}%` : 'Scanning…'
+	}
+	return results.value ? 'Rescan' : 'Find silence & dead air'
+})
+
+const seekToRegion = (r: { start: number; end: number }) => {
+	const t = editorStore.sourceTimeToTimeline(props.assetId, r.start)
+	if (t !== null) editorStore.seekTo(t)
+}
+
+const formatTime = (seconds: number) => {
+	const m = Math.floor(seconds / 60)
+	const s = Math.floor(seconds % 60)
+	const ms = Math.floor((seconds % 1) * 100)
+	return `${m}:${String(s).padStart(2, '0')}.${String(ms).padStart(2, '0')}`
+}
+</script>
diff --git a/src/renderer/src/editor/components/TimelinePanel.vue b/src/renderer/src/editor/components/TimelinePanel.vue
new file mode 100644
index 0000000..5ccdf27
--- /dev/null
+++ b/src/renderer/src/editor/components/TimelinePanel.vue
@@ -0,0 +1,97 @@
+<template>
+	<div class="glass-card rounded-2xl flex flex-col overflow-hidden relative">
+		<TimelineToolbar />
+		<TimelineMinimap />
+
+		<div class="flex-1 min-h-0 grid grid-cols-[112px_1fr]">
+			<!-- Left: track headers. The ruler spacer stays pinned; the header
+			     stack is translated to follow the lanes' vertical scroll. -->
+			<div class="border-r border-zinc-200 dark:border-zinc-800 bg-zinc-50/50 dark:bg-zinc-950/40 overflow-hidden flex flex-col">
+				<div class="h-6 border-b border-zinc-200 dark:border-zinc-800 shrink-0"></div> <!-- ruler spacer -->
+				<div :style="{ transform: `translateY(${-vScroll}px)` }">
+					<TrackHeader v-for="track in store.sortedTracks" :key="track.id" :track="track" />
+				</div>
+			</div>
+
+			<!-- Right: ONE scroll container shared by ruler + lanes (x AND y) -->
+			<div ref="scrollRef"
+				class="relative overflow-x-auto overflow-y-auto custom-scrollbar"
+				role="application" aria-label="Timeline — Space to play, S to split, Delete to ripple-delete, arrows to step"
+				@scroll="onScroll" @wheel="onWheel">
+				<div class="relative" :style="{ width: `${viewport.contentWidth.value}px`, minWidth: '100%' }">
+					<!-- Ruler pinned to the top while the lanes scroll vertically -->
+					<div class="sticky top-0 z-30 bg-zinc-50/95 dark:bg-zinc-950/95 backdrop-blur-sm">
+						<TimelineRuler />
+					</div>
+					<TrackLane v-for="track in store.sortedTracks" :key="track.id" :track="track" />
+					<TimelinePlayhead />
+					<!-- Snap guide -->
+					<div v-if="interactions.snapGuideSec.value !== null"
+						class="absolute top-0 bottom-0 w-px bg-secondary z-20 pointer-events-none shadow-[0_0_6px_rgba(139,92,246,0.6)]"
+						:style="{ transform: `translateX(${viewport.secToPx(interactions.snapGuideSec.value)}px)` }"></div>
+				</div>
+			</div>
+		</div>
+
+		<!-- Screen-reader announcements -->
+		<div class="sr-only" aria-live="polite">{{ announcement }}</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, provide, ref, watch } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+import {
+	useTimelineViewport, TimelineViewportKey, TimelineInteractionsKey
+} from '../composables/useTimelineViewport'
+import { useTimelineInteractions } from '../composables/useTimelineInteractions'
+import { useEditorShortcuts } from '../composables/useEditorShortcuts'
+import TimelineToolbar from './timeline/TimelineToolbar.vue'
+import TimelineMinimap from './timeline/TimelineMinimap.vue'
+import TimelineRuler from './timeline/TimelineRuler.vue'
+import TrackHeader from './timeline/TrackHeader.vue'
+import TrackLane from './timeline/TrackLane.vue'
+import TimelinePlayhead from './timeline/TimelinePlayhead.vue'
+
+const store = useEditorStore()
+
+const viewport = useTimelineViewport()
+const interactions = useTimelineInteractions(viewport)
+
+provide(TimelineViewportKey, viewport)
+provide(TimelineInteractionsKey, interactions)
+
+// Global editor shortcuts (guarded against typing contexts) — the timeline
+// panel is always mounted on the editor page and owns the zoom functions.
+useEditorShortcuts((factor) => viewport.zoomBy(factor))
+
+const scrollRef = ref<HTMLElement | null>(null)
+const vScroll = ref(0) // vertical scroll of the lanes, mirrored onto the headers
+
+onMounted(() => viewport.setScrollEl(scrollRef.value))
+
+// The lanes container owns both axes; forward horizontal scroll to the viewport
+// and mirror vertical scroll onto the (transform-driven) header column.
+const onScroll = (e: Event) => {
+	viewport.onScroll()
+	vScroll.value = (e.target as HTMLElement).scrollTop
+}
+
+const onWheel = (e: WheelEvent) => {
+	if (e.ctrlKey || e.metaKey) {
+		e.preventDefault()
+		viewport.zoomAtCursor(e)
+	}
+}
+
+// Keep the playhead in view while playing
+watch(() => store.playheadSec, (t) => {
+	if (store.isPlaying) viewport.scrollToTime(t)
+})
+
+const announcement = computed(() => {
+	const m = Math.floor(store.playheadSec / 60)
+	const s = (store.playheadSec % 60).toFixed(1)
+	return `Playhead at ${m}:${s.padStart(4, '0')}`
+})
+</script>
diff --git a/src/renderer/src/editor/components/timeline/TimelineClip.vue b/src/renderer/src/editor/components/timeline/TimelineClip.vue
new file mode 100644
index 0000000..39ead36
--- /dev/null
+++ b/src/renderer/src/editor/components/timeline/TimelineClip.vue
@@ -0,0 +1,155 @@
+<template>
+	<div class="absolute top-1 bottom-1 rounded-lg overflow-hidden select-none group border transition-shadow"
+		:class="[
+			selected
+				? 'border-primary ring-2 ring-primary/40 shadow-md shadow-primary/20 z-10'
+				: 'border-zinc-300/60 dark:border-zinc-700/80 hover:border-primary/40',
+			track?.locked ? 'pointer-events-none opacity-60' : 'cursor-grab active:cursor-grabbing'
+		]"
+		:style="{ transform: `translateX(${viewport.secToPx(item.timelineStart)}px)`, width: `${Math.max(viewport.secToPx(item.duration), 6)}px` }"
+		role="option" :aria-selected="selected" tabindex="0"
+		:aria-label="`${item.label || 'Clip'}, ${format(item.timelineStart)} to ${format(end)}, ${item.duration.toFixed(1)} seconds`"
+		@pointerenter="hovering = true"
+		@pointerleave="hovering = false"
+		@pointerdown.stop="onPointerDown"
+		@click.stop="onClick">
+
+		<!-- Body: filmstrip (scene thumbnail) or context (visual text) -->
+		<div class="absolute inset-0 bg-zinc-200 dark:bg-zinc-800">
+			<template v-if="store.timelineView === 'filmstrip'">
+				<!-- Dense strip (§5.5): frames from the batched per-asset filmstrip,
+				     one per ~64px slot; falls back to the scene thumbnail. -->
+				<div v-if="stripFrames.length" class="w-full h-full flex">
+					<img v-for="(src, i) in stripFrames" :key="i" :src="src"
+						class="flex-1 min-w-0 h-full object-cover" loading="lazy" draggable="false" />
+				</div>
+				<img v-else-if="thumbSrc" :src="thumbSrc" class="w-full h-full object-cover" loading="lazy" draggable="false" />
+				<div v-else class="w-full h-full flex items-center justify-center"
+					:class="isAudio ? 'bg-accent/10' : ''">
+					<span class="iconify w-4 h-4" :class="[isAudio ? 'tabler--music text-accent' : 'tabler--movie text-zinc-400']"></span>
+				</div>
+				<div class="absolute bottom-0 inset-x-0 px-1.5 py-0.5 bg-gradient-to-t from-black/60 to-transparent">
+					<p class="text-[9px] text-white/90 truncate font-medium">{{ item.label }}</p>
+				</div>
+			</template>
+			<template v-else>
+				<div class="w-full h-full px-2 py-1 bg-white/70 dark:bg-zinc-900/70 flex flex-col justify-center gap-0.5 overflow-hidden">
+					<span class="text-[8px] font-mono text-zinc-400 leading-none">
+						{{ format(item.in) }}–{{ format(item.out) }}
+					</span>
+					<p class="text-[10px] leading-tight text-zinc-700 dark:text-zinc-300 line-clamp-2"
+						:class="{ 'italic text-zinc-400 dark:text-zinc-500': !contextText }">
+						{{ contextText || 'No description — run enrichment' }}
+					</p>
+				</div>
+			</template>
+
+			<!-- Retime hatch + badge -->
+			<div v-if="item.speed !== 1" class="absolute inset-0 pointer-events-none retime-hatch"></div>
+			<span v-if="item.speed !== 1"
+				class="absolute top-0.5 right-0.5 px-1 py-px rounded bg-secondary text-white text-[8px] font-bold font-mono pointer-events-none">
+				{{ item.speed.toFixed(2).replace(/\.?0+$/, '') }}×
+			</span>
+			<!-- Item muted badge -->
+			<span v-if="item.muted"
+				class="absolute top-0.5 left-0.5 w-3.5 h-3.5 rounded bg-black/50 flex items-center justify-center pointer-events-none">
+				<span class="iconify tabler--volume-off w-2.5 h-2.5 text-white"></span>
+			</span>
+		</div>
+
+		<!-- Trim handles -->
+		<div v-if="selected || hovering" class="absolute inset-y-0 left-0 w-1.5 bg-primary/80 cursor-ew-resize z-20"
+			@pointerdown.stop="interactions.beginTrim(item.id, 'left', $event)"></div>
+		<div v-if="selected || hovering" class="absolute inset-y-0 right-0 w-1.5 bg-primary/80 cursor-ew-resize z-20"
+			@pointerdown.stop="interactions.beginTrim(item.id, 'right', $event)"></div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, inject, ref } from 'vue'
+import type { TimelineItem } from '@shared/types'
+import { itemEnd } from '@shared/timeline'
+import { useEditorStore } from '../../../stores/editorStore'
+import { TimelineViewportKey, TimelineInteractionsKey } from '../../composables/useTimelineViewport'
+
+const props = defineProps<{ item: TimelineItem }>()
+
+const store = useEditorStore()
+const viewport = inject(TimelineViewportKey)!
+const interactions = inject(TimelineInteractionsKey)!
+
+const hovering = ref(false)
+
+const selected = computed(() => store.selectedItemIds.includes(props.item.id))
+const end = computed(() => itemEnd(props.item))
+const track = computed(() => store.doc?.tracks.find((t) => t.id === props.item.trackId))
+const isAudio = computed(() =>
+	store.doc?.media.find((a) => a.id === props.item.sourceAssetId)?.kind === 'audio')
+
+const sourceClip = computed(() => {
+	const asset = store.doc?.media.find((a) => a.id === props.item.sourceAssetId)
+	return asset?.clips.find((c) => c.id === props.item.sourceClipId) || null
+})
+
+const thumbSrc = computed(() =>
+	sourceClip.value?.thumbnailPath ? `media://${sourceClip.value.thumbnailPath}` : null
+)
+
+// Dense filmstrip (§5.5): pick the nearest batched-strip frame for each
+// ~64px slot across the clip's SOURCE range. Density adapts to zoom via the
+// on-screen width; entries are asset-cached, so this is pure lookup.
+const TARGET_FRAME_PX = 64
+const stripFrames = computed<string[]>(() => {
+	const entries = store.doc?.media.find((a) => a.id === props.item.sourceAssetId)?.filmstrip
+	if (!entries?.length) return []
+	const widthPx = viewport.secToPx(props.item.duration)
+	const count = Math.min(Math.max(Math.floor(widthPx / TARGET_FRAME_PX), 1), 60)
+	const span = props.item.out - props.item.in
+	const frames: string[] = []
+	for (let i = 0; i < count; i++) {
+		const t = props.item.in + ((i + 0.5) / count) * span
+		// entries are sorted by time — nearest lookup
+		let best = entries[0]
+		for (const e of entries) {
+			if (Math.abs(e.time - t) < Math.abs(best.time - t)) best = e
+			if (e.time > t) break
+		}
+		frames.push(`media://${best.thumbnailPath}`)
+	}
+	return frames
+})
+
+const contextText = computed(() => sourceClip.value?.visual || props.item.label || '')
+
+const format = (seconds: number) => {
+	const m = Math.floor(seconds / 60)
+	const s = (seconds % 60).toFixed(1)
+	return `${m}:${s.padStart(4, '0')}`
+}
+
+const onPointerDown = (e: PointerEvent) => {
+	if (!selected.value) {
+		if (e.shiftKey || e.metaKey || e.ctrlKey) store.toggleItemSelected(props.item.id)
+		else store.selectItems([props.item.id])
+	}
+	interactions.beginMove(props.item.id, e)
+}
+
+const onClick = (e: MouseEvent) => {
+	if (e.shiftKey || e.metaKey || e.ctrlKey) return // handled at pointerdown
+	store.selectItems([props.item.id])
+}
+</script>
+
+<style scoped>
+.retime-hatch {
+	background-image: repeating-linear-gradient(
+		-45deg,
+		transparent,
+		transparent 6px,
+		rgba(139, 92, 246, 0.15) 6px,
+		rgba(139, 92, 246, 0.15) 8px
+	);
+}
+
+</style>
diff --git a/src/renderer/src/editor/components/timeline/TimelineMinimap.vue b/src/renderer/src/editor/components/timeline/TimelineMinimap.vue
new file mode 100644
index 0000000..7c744db
--- /dev/null
+++ b/src/renderer/src/editor/components/timeline/TimelineMinimap.vue
@@ -0,0 +1,90 @@
+<template>
+	<!-- Always-visible overview strip (§5.3): the whole sequence at a glance,
+	     with a draggable viewport rectangle. Navigation only — it scrolls the
+	     main timeline and never moves the playhead. -->
+	<div ref="rootRef"
+		class="relative h-5 shrink-0 border-b border-zinc-200 dark:border-zinc-800 bg-zinc-100/60 dark:bg-zinc-900/60 cursor-pointer select-none touch-none"
+		title="Timeline overview — click or drag to navigate"
+		@pointerdown="onPointerDown">
+		<!-- Item blocks, one thin row per track -->
+		<div v-for="(track, row) in store.sortedTracks" :key="track.id">
+			<div v-for="item in itemsByTrack[track.id] || []" :key="item.id"
+				class="absolute rounded-[1px]"
+				:class="trackTint(track.kind)"
+				:style="{
+					left: `${frac(item.timelineStart) * 100}%`,
+					width: `${Math.max(frac(item.duration) * 100, 0.15)}%`,
+					top: `${3 + row * 4}px`,
+					height: '3px'
+				}"></div>
+		</div>
+
+		<!-- Markers -->
+		<div v-for="m in store.markers" :key="m.id"
+			class="absolute top-0 bottom-0 w-px bg-amber-400/90"
+			:style="{ left: `${frac(m.time) * 100}%` }"></div>
+
+		<!-- Playhead -->
+		<div class="absolute top-0 bottom-0 w-px bg-primary"
+			:style="{ left: `${frac(store.playheadSec) * 100}%` }"></div>
+
+		<!-- Visible-window rectangle -->
+		<div class="absolute top-0 bottom-0 border border-primary/60 bg-primary/10 rounded-[2px] pointer-events-none"
+			:style="{ left: `${windowLeftFrac * 100}%`, width: `${windowWidthFrac * 100}%` }"></div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, inject, ref } from 'vue'
+import { useEditorStore } from '../../../stores/editorStore'
+import { TimelineViewportKey } from '../../composables/useTimelineViewport'
+
+const store = useEditorStore()
+const viewport = inject(TimelineViewportKey)!
+
+const rootRef = ref<HTMLElement | null>(null)
+
+// The minimap maps the SAME domain as the scroll content ([0, contentEnd+tail])
+// so the window rectangle tracks scrollLeft/clientWidth exactly.
+const totalSec = computed(() => Math.max(store.contentEnd + store.timelineTail, 1))
+const frac = (sec: number) => Math.min(Math.max(sec / totalSec.value, 0), 1)
+
+const itemsByTrack = computed(() => store.itemsByTrack)
+
+const windowLeftFrac = computed(() =>
+	viewport.contentWidth.value > 0 ? viewport.scrollLeft.value / viewport.contentWidth.value : 0
+)
+const windowWidthFrac = computed(() =>
+	viewport.contentWidth.value > 0
+		? Math.min(viewport.clientWidth.value / viewport.contentWidth.value, 1)
+		: 1
+)
+
+const trackTint = (kind: string) =>
+	kind === 'audio' ? 'bg-accent/70' : kind === 'video' ? 'bg-primary/70' : 'bg-secondary/60'
+
+/** Scroll the main timeline so the clicked/dragged fraction is centered. */
+const navigateTo = (clientX: number) => {
+	const root = rootRef.value
+	const el = viewport.scrollEl.value
+	if (!root || !el) return
+	const rect = root.getBoundingClientRect()
+	const f = Math.min(Math.max((clientX - rect.left) / rect.width, 0), 1)
+	el.scrollLeft = f * viewport.contentWidth.value - el.clientWidth / 2
+	viewport.onScroll()
+}
+
+const onPointerDown = (e: PointerEvent) => {
+	navigateTo(e.clientX)
+	const el = rootRef.value
+	if (!el) return
+	el.setPointerCapture(e.pointerId)
+	const onMove = (ev: PointerEvent) => navigateTo(ev.clientX)
+	const onUp = () => {
+		el.removeEventListener('pointermove', onMove)
+		el.removeEventListener('pointerup', onUp)
+	}
+	el.addEventListener('pointermove', onMove)
+	el.addEventListener('pointerup', onUp)
+}
+</script>
diff --git a/src/renderer/src/editor/components/timeline/TimelinePlayhead.vue b/src/renderer/src/editor/components/timeline/TimelinePlayhead.vue
new file mode 100644
index 0000000..ea7fe33
--- /dev/null
+++ b/src/renderer/src/editor/components/timeline/TimelinePlayhead.vue
@@ -0,0 +1,29 @@
+<template>
+	<div class="absolute top-0 bottom-0 z-30 pointer-events-none"
+		:style="{ transform: `translateX(${viewport.secToPx(store.playheadSec)}px)` }"
+		role="slider" aria-label="Playhead"
+		:aria-valuetext="ariaTime" :aria-valuenow="Math.round(store.playheadSec)"
+		:aria-valuemin="0" :aria-valuemax="Math.round(store.contentEnd)">
+		<!-- Grab handle (on the ruler) -->
+		<div class="absolute -top-0 -ml-[5px] w-[11px] h-3.5 bg-primary rounded-b-sm cursor-ew-resize pointer-events-auto shadow"
+			@pointerdown.stop="interactions.beginScrub($event)"></div>
+		<!-- Line -->
+		<div class="absolute top-0 bottom-0 w-px bg-primary shadow-[0_0_6px_rgba(59,130,246,0.6)]"></div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, inject } from 'vue'
+import { useEditorStore } from '../../../stores/editorStore'
+import { TimelineViewportKey, TimelineInteractionsKey } from '../../composables/useTimelineViewport'
+
+const store = useEditorStore()
+const viewport = inject(TimelineViewportKey)!
+const interactions = inject(TimelineInteractionsKey)!
+
+const ariaTime = computed(() => {
+	const m = Math.floor(store.playheadSec / 60)
+	const s = (store.playheadSec % 60).toFixed(1)
+	return `${m} minutes ${s} seconds`
+})
+</script>
diff --git a/src/renderer/src/editor/components/timeline/TimelineRuler.vue b/src/renderer/src/editor/components/timeline/TimelineRuler.vue
new file mode 100644
index 0000000..fb59142
--- /dev/null
+++ b/src/renderer/src/editor/components/timeline/TimelineRuler.vue
@@ -0,0 +1,68 @@
+<template>
+	<div class="relative h-6 border-b border-zinc-200 dark:border-zinc-800 cursor-pointer select-none bg-zinc-50/80 dark:bg-zinc-950/60"
+		@pointerdown="interactions.beginScrub($event)">
+		<!-- Ticks -->
+		<div v-for="tick in ticks" :key="tick.time"
+			class="absolute top-0 bottom-0 pointer-events-none"
+			:style="{ transform: `translateX(${viewport.secToPx(tick.time)}px)` }">
+			<div class="w-px bg-zinc-300 dark:bg-zinc-700" :class="tick.major ? 'h-full' : 'h-1.5 mt-auto absolute bottom-0'"></div>
+			<span v-if="tick.major" class="absolute top-0.5 left-1 text-[8px] font-mono text-zinc-400 whitespace-nowrap">
+				{{ tick.label }}
+			</span>
+		</div>
+
+		<!-- Markers -->
+		<button v-for="marker in store.markers" :key="marker.id"
+			class="absolute -bottom-px w-2.5 h-2.5 -ml-[5px] rotate-45 bg-secondary border border-white/50 dark:border-zinc-900/50 hover:scale-125 transition-transform z-10"
+			:style="{ left: `${viewport.secToPx(marker.time)}px` }"
+			:title="`${marker.label || 'Marker'} — click to seek, Alt-click to remove`"
+			@pointerdown.stop
+			@click.stop="onMarkerClick(marker.id, marker.time, $event)"></button>
+
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, inject } from 'vue'
+import { useEditorStore } from '../../../stores/editorStore'
+import { TimelineViewportKey, TimelineInteractionsKey } from '../../composables/useTimelineViewport'
+
+const store = useEditorStore()
+const viewport = inject(TimelineViewportKey)!
+const interactions = inject(TimelineInteractionsKey)!
+
+const TICK_STEPS = [0.5, 1, 2, 5, 10, 30, 60, 300]
+
+const ticks = computed(() => {
+	// Choose the smallest step giving >= 60px between major ticks
+	const step = TICK_STEPS.find((s) => viewport.secToPx(s) >= 60) || 300
+	const minor = step / 5
+	const [visStart, visEnd] = viewport.visibleRange.value
+	const start = Math.max(0, Math.floor(visStart / minor) * minor)
+	const end = Math.min(store.contentEnd + store.timelineTail, visEnd)
+
+	const out: { time: number; major: boolean; label: string }[] = []
+	for (let t = start; t <= end + 1e-9; t += minor) {
+		const time = Math.round(t * 1000) / 1000
+		const major = Math.abs(time / step - Math.round(time / step)) < 1e-6
+		out.push({ time, major, label: major ? format(time, step) : '' })
+	}
+	return out
+})
+
+// Label precision follows the tick step so sub-second majors stay distinct
+// (step 0.5 -> "0s, 0.5s, 1s" — not "0s, 0s, 1s").
+const format = (seconds: number, step: number) => {
+	if (seconds >= 60 || step >= 60) {
+		const m = Math.floor(seconds / 60)
+		const s = Math.floor(seconds % 60)
+		return `${m}:${String(s).padStart(2, '0')}`
+	}
+	return step < 1 ? `${(Math.round(seconds * 10) / 10)}s` : `${Math.round(seconds)}s`
+}
+
+const onMarkerClick = (id: string, time: number, e: MouseEvent) => {
+	if (e.altKey) store.removeMarker(id)
+	else store.seekTo(time)
+}
+</script>
diff --git a/src/renderer/src/editor/components/timeline/TimelineToolbar.vue b/src/renderer/src/editor/components/timeline/TimelineToolbar.vue
new file mode 100644
index 0000000..4c25d66
--- /dev/null
+++ b/src/renderer/src/editor/components/timeline/TimelineToolbar.vue
@@ -0,0 +1,124 @@
+<template>
+	<div class="px-3 py-1.5 flex items-center justify-between border-b border-zinc-200 dark:border-zinc-800 shrink-0 gap-2">
+		<div class="flex items-center gap-2">
+			<span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500">Timeline</span>
+
+			<!-- View toggle: Filmstrip / Context -->
+			<div class="flex items-center bg-zinc-100/80 dark:bg-zinc-900/80 rounded-md p-0.5 border border-zinc-200 dark:border-zinc-800">
+				<button v-for="view in (['filmstrip', 'context'] as const)" :key="view"
+					:title="`${view} view`"
+					class="px-1.5 py-0.5 rounded text-[9px] font-bold uppercase tracking-widest transition flex items-center gap-1"
+					:class="store.timelineView === view
+						? 'bg-primary text-white shadow-sm shadow-primary/20'
+						: 'text-zinc-500 hover:text-zinc-700 dark:hover:text-zinc-300'"
+					@click="store.timelineView = view">
+					<span :class="view === 'filmstrip' ? 'iconify tabler--photo' : 'iconify tabler--file-text'" class="w-2.5 h-2.5"></span>
+					{{ view }}
+				</button>
+			</div>
+		</div>
+
+		<div class="flex items-center gap-1">
+			<!-- Undo / Redo -->
+			<ToolButton icon="tabler--arrow-back-up" title="Undo (⌘Z)" :disabled="!store.canUndo" @click="store.undo()" />
+			<ToolButton icon="tabler--arrow-forward-up" title="Redo (⌘⇧Z)" :disabled="!store.canRedo" @click="store.redo()" />
+			<div class="w-px h-4 bg-zinc-200 dark:bg-zinc-800 mx-1"></div>
+
+			<!-- Edit tools -->
+			<ToolButton icon="tabler--blade-filled" title="Split at playhead (S)" @click="store.splitAtPlayhead()" />
+			<ToolButton icon="tabler--trash" title="Ripple delete selection (⌫)"
+				:disabled="!store.selectedItemIds.length"
+				@click="store.deleteItems(store.selectedItemIds)" />
+			<ToolButton icon="tabler--magnet" :title="store.snapEnabled ? 'Snapping on' : 'Snapping off'"
+				:active="store.snapEnabled" @click="store.snapEnabled = !store.snapEnabled" />
+			<div class="w-px h-4 bg-zinc-200 dark:bg-zinc-800 mx-1"></div>
+
+			<!-- Marker / chapter jump list (§5.3) -->
+			<div class="relative">
+				<ToolButton icon="tabler--bookmarks" title="Markers & chapters"
+					:active="markersOpen" @click="markersOpen = !markersOpen" />
+				<template v-if="markersOpen">
+					<div class="fixed inset-0 z-40" @click="markersOpen = false"></div>
+					<div class="absolute right-0 top-7 z-50 w-60 glass-card rounded-xl border border-zinc-200 dark:border-zinc-800 shadow-lg py-1 max-h-52 overflow-y-auto custom-scrollbar origin-top animate-menu">
+						<p v-if="!store.markers.length" class="px-3 py-2 text-[11px] text-zinc-400">
+							No markers yet — press <span class="font-mono font-bold">M</span> at the playhead to add one.
+						</p>
+						<div v-for="m in store.markers" :key="m.id"
+							class="flex items-center gap-1 px-1.5 group">
+							<button
+								class="flex-1 flex items-center justify-between gap-2 px-1.5 py-1.5 rounded-lg text-left hover:bg-primary/10 transition min-w-0"
+								@click="jumpToMarker(m.time)">
+								<span class="text-[11px] text-zinc-700 dark:text-zinc-200 truncate">
+									{{ m.label || 'Marker' }}
+								</span>
+								<span class="font-mono text-[10px] text-zinc-400 shrink-0">{{ formatTime(m.time) }}</span>
+							</button>
+							<button title="Remove marker"
+								class="p-1 rounded-md text-zinc-300 dark:text-zinc-600 opacity-0 group-hover:opacity-100 hover:text-red-500 transition"
+								@click="store.removeMarker(m.id)">
+								<span class="iconify tabler--x w-3 h-3 block"></span>
+							</button>
+						</div>
+					</div>
+				</template>
+			</div>
+			<div class="w-px h-4 bg-zinc-200 dark:bg-zinc-800 mx-1"></div>
+
+			<!-- Zoom -->
+			<ToolButton icon="tabler--zoom-out" title="Zoom out (−)" @click="viewport.zoomBy(0.8)" />
+			<ToolButton icon="tabler--zoom-in" title="Zoom in (+)" @click="viewport.zoomBy(1.25)" />
+			<ToolButton icon="tabler--arrows-horizontal" title="Fit timeline" @click="viewport.fitToWindow()" />
+			<ToolButton icon="tabler--focus-2" title="Fit selection" :disabled="!store.selectedItemIds.length"
+				@click="viewport.fitToSelection()" />
+			<div class="w-px h-4 bg-zinc-200 dark:bg-zinc-800 mx-1"></div>
+
+			<ToolButton icon="tabler--plus" title="Add overlay track" @click="store.addOverlayTrack()" />
+			<ToolButton icon="tabler--bookmark-plus" title="Save revision checkpoint"
+				@click="store.saveCheckpoint()" />
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { h, inject, ref } from 'vue'
+import type { FunctionalComponent } from 'vue'
+import { useEditorStore } from '../../../stores/editorStore'
+import { TimelineViewportKey } from '../../composables/useTimelineViewport'
+
+const store = useEditorStore()
+const viewport = inject(TimelineViewportKey)!
+
+const markersOpen = ref(false)
+
+const jumpToMarker = (time: number) => {
+	store.seekTo(time)
+	viewport.scrollToTime(time)
+	markersOpen.value = false
+}
+
+const formatTime = (seconds: number) => {
+	const m = Math.floor(seconds / 60)
+	const s = Math.floor(seconds % 60)
+	return `${m}:${String(s).padStart(2, '0')}`
+}
+
+const ToolButton: FunctionalComponent<
+	{ icon: string; title: string; disabled?: boolean; active?: boolean },
+	{ click: () => void }
+> = (props, { emit }) =>
+	h('button', {
+		class: [
+			'w-6 h-6 flex items-center justify-center rounded-lg transition active:scale-95',
+			props.disabled
+				? 'text-zinc-300 dark:text-zinc-700 cursor-not-allowed'
+				: props.active
+					? 'text-primary bg-primary/10'
+					: 'text-zinc-500 hover:text-primary hover:bg-primary/10'
+		],
+		title: props.title,
+		disabled: props.disabled,
+		onClick: () => { if (!props.disabled) emit('click') }
+	}, [h('span', { class: `iconify ${props.icon} w-3.5 h-3.5` })])
+ToolButton.props = ['icon', 'title', 'disabled', 'active']
+ToolButton.emits = ['click']
+</script>
diff --git a/src/renderer/src/editor/components/timeline/TrackHeader.vue b/src/renderer/src/editor/components/timeline/TrackHeader.vue
new file mode 100644
index 0000000..56348cc
--- /dev/null
+++ b/src/renderer/src/editor/components/timeline/TrackHeader.vue
@@ -0,0 +1,37 @@
+<template>
+	<div class="flex items-center justify-between px-2 border-b border-zinc-200/60 dark:border-zinc-800/60"
+		:style="{ height: `${track.height}px` }">
+		<span class="text-[9px] font-bold uppercase tracking-widest"
+			:class="track.hidden ? 'text-zinc-300 dark:text-zinc-700' : 'text-zinc-500'">
+			{{ track.name }}
+		</span>
+		<div class="flex items-center gap-0.5">
+			<button class="w-5 h-5 flex items-center justify-center rounded transition"
+				:class="track.muted ? 'text-red-500 bg-red-500/10' : 'text-zinc-400 hover:text-zinc-600 dark:hover:text-zinc-300'"
+				:title="track.muted ? 'Unmute track' : 'Mute track'"
+				@click="store.toggleTrackFlag(track.id, 'muted')">
+				<span :class="track.muted ? 'iconify tabler--volume-off' : 'iconify tabler--volume'" class="w-3 h-3"></span>
+			</button>
+			<button class="w-5 h-5 flex items-center justify-center rounded transition"
+				:class="track.locked ? 'text-amber-500 bg-amber-500/10' : 'text-zinc-400 hover:text-zinc-600 dark:hover:text-zinc-300'"
+				:title="track.locked ? 'Unlock track' : 'Lock track'"
+				@click="store.toggleTrackFlag(track.id, 'locked')">
+				<span :class="track.locked ? 'iconify tabler--lock' : 'iconify tabler--lock-open'" class="w-3 h-3"></span>
+			</button>
+			<button class="w-5 h-5 flex items-center justify-center rounded transition"
+				:class="track.hidden ? 'text-zinc-600 dark:text-zinc-300 bg-zinc-500/10' : 'text-zinc-400 hover:text-zinc-600 dark:hover:text-zinc-300'"
+				:title="track.hidden ? 'Show track' : 'Hide track'"
+				@click="store.toggleTrackFlag(track.id, 'hidden')">
+				<span :class="track.hidden ? 'iconify tabler--eye-off' : 'iconify tabler--eye'" class="w-3 h-3"></span>
+			</button>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import type { Track } from '@shared/types'
+import { useEditorStore } from '../../../stores/editorStore'
+
+defineProps<{ track: Track }>()
+const store = useEditorStore()
+</script>
diff --git a/src/renderer/src/editor/components/timeline/TrackLane.vue b/src/renderer/src/editor/components/timeline/TrackLane.vue
new file mode 100644
index 0000000..00f9b3c
--- /dev/null
+++ b/src/renderer/src/editor/components/timeline/TrackLane.vue
@@ -0,0 +1,104 @@
+<template>
+	<div class="relative border-b border-zinc-200/60 dark:border-zinc-800/60 transition-colors"
+		:data-track-id="track.id"
+		:style="{ height: `${track.height}px` }"
+		:class="[laneTint, { 'opacity-40': track.hidden, 'bg-zinc-500/5': dragOver }]"
+		role="group" :aria-label="`${track.name} ${track.kind} track`"
+		@dragover="onDragOver" @dragleave="dragOver = false" @drop="onDrop"
+		@pointerdown="onLanePointerDown">
+
+		<!-- Windowed clip rendering -->
+		<TimelineClip v-for="item in visibleItems" :key="item.id" :item="item" />
+
+		<!-- Hints -->
+		<div v-if="items.length === 0" class="absolute inset-0 flex items-center px-3 pointer-events-none">
+			<span class="text-[10px] text-zinc-400 dark:text-zinc-600">{{ emptyHint }}</span>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, inject, ref } from 'vue'
+import type { Track } from '@shared/types'
+import { itemEnd } from '@shared/timeline'
+import { useEditorStore } from '../../../stores/editorStore'
+import { TimelineViewportKey } from '../../composables/useTimelineViewport'
+import TimelineClip from './TimelineClip.vue'
+
+const props = defineProps<{ track: Track }>()
+
+const store = useEditorStore()
+const viewport = inject(TimelineViewportKey)!
+
+const dragOver = ref(false)
+
+const items = computed(() => store.itemsByTrack[props.track.id] || [])
+
+const visibleItems = computed(() =>
+	items.value.filter((i) => viewport.intersectsVisible(i.timelineStart, itemEnd(i)))
+)
+
+const laneTint = computed(() => {
+	switch (props.track.kind) {
+		case 'video': return 'bg-primary/[0.03] dark:bg-primary/[0.05]'
+		case 'audio': return 'bg-accent/[0.03] dark:bg-accent/[0.05]'
+		default: return ''
+	}
+})
+
+const emptyHint = computed(() => {
+	switch (props.track.kind) {
+		case 'video': return 'Drag a file or pieces here'
+		case 'audio': return 'Drag an audio file or pieces here'
+		default: return 'Overlay authoring arrives later'
+	}
+})
+
+// A lane accepts video/audio drops when unlocked/visible AND the dragged item's
+// kind (from the readable kind-hint type) matches the lane. Overlay/text lanes
+// stay inert in v1.
+const dropKind = computed<'video' | 'audio' | null>(() => {
+	if (props.track.locked || props.track.hidden) return null
+	if (props.track.kind === 'video') return 'video'
+	if (props.track.kind === 'audio') return 'audio'
+	return null
+})
+
+const canAcceptDrag = (dt: DataTransfer | null): boolean => {
+	if (!dt || !dropKind.value) return false
+	const isPayload = dt.types.includes('application/x-frameflow-clip') || dt.types.includes('application/x-frameflow-asset')
+	return isPayload && dt.types.includes(`application/x-frameflow-kind-${dropKind.value}`)
+}
+
+const onDragOver = (e: DragEvent) => {
+	if (!canAcceptDrag(e.dataTransfer)) {
+		if (e.dataTransfer) e.dataTransfer.dropEffect = 'none'
+		return
+	}
+	e.preventDefault()
+	e.dataTransfer!.dropEffect = 'copy'
+	dragOver.value = true
+}
+
+const onDrop = (e: DragEvent) => {
+	dragOver.value = false
+	if (!canAcceptDrag(e.dataTransfer)) return
+	e.preventDefault()
+	const el = viewport.scrollEl.value
+	if (!el) return
+	const rect = el.getBoundingClientRect()
+	const atSec = Math.max(0, viewport.pxToSec(el.scrollLeft + (e.clientX - rect.left)))
+
+	const assetId = e.dataTransfer!.getData('application/x-frameflow-asset')
+	if (assetId) { store.addItemFromAsset(assetId, props.track.id, atSec); return }
+	const clipId = e.dataTransfer!.getData('application/x-frameflow-clip')
+	if (clipId) store.addItemFromClip(clipId, props.track.id, atSec)
+}
+
+// Clicking empty lane space clears selection
+const onLanePointerDown = (e: PointerEvent) => {
+	if ((e.target as HTMLElement).dataset.trackId === props.track.id) {
+		store.clearItemSelection()
+	}
+}
+</script>
diff --git a/src/renderer/src/editor/composables/useEditorShortcuts.ts b/src/renderer/src/editor/composables/useEditorShortcuts.ts
new file mode 100644
index 0000000..bd386b2
--- /dev/null
+++ b/src/renderer/src/editor/composables/useEditorShortcuts.ts
@@ -0,0 +1,98 @@
+import { onMounted, onUnmounted } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+
+/**
+ * Global keyboard shortcuts for the editor page (PRD §5.11).
+ * Never fires while the user is typing in an input/textarea/select/
+ * contenteditable — that guard is the first line.
+ *
+ * Space        play/pause          M              add marker at playhead
+ * ← / →        frame-step playhead S or Cmd/Ctrl+B split at playhead
+ * Shift+←/→    nudge selection 1f  Delete/Backsp  ripple-delete selection
+ * Alt+Shift+←/→ nudge 1s           Shift+Delete   delete leaving gap
+ * Home / End   sequence start/end  Cmd/Ctrl+Z     undo
+ * + / -        zoom                Cmd/Ctrl+Shift+Z redo
+ * Esc          clear selection
+ */
+export function useEditorShortcuts(zoomBy?: (factor: number) => void) {
+	const store = useEditorStore()
+
+	const frameStep = () => 1 / (store.doc?.timelineMeta.fps || 30)
+
+	const onKeyDown = (e: KeyboardEvent) => {
+		const target = e.target as HTMLElement | null
+		if (target?.closest('input, textarea, select, [contenteditable="true"]')) return
+		if (!store.doc) return
+
+		const meta = e.metaKey || e.ctrlKey
+
+		// Undo / redo
+		if (meta && e.key.toLowerCase() === 'z') {
+			e.preventDefault()
+			if (e.shiftKey) store.redo()
+			else store.undo()
+			return
+		}
+
+		// Split
+		if ((meta && e.key.toLowerCase() === 'b') || (!meta && (e.key === 's' || e.key === 'S'))) {
+			e.preventDefault()
+			store.splitAtPlayhead()
+			return
+		}
+
+		switch (e.key) {
+			case ' ':
+				e.preventDefault()
+				store.isPlaying = !store.isPlaying
+				return
+			case 'ArrowLeft':
+			case 'ArrowRight': {
+				e.preventDefault()
+				const direction = e.key === 'ArrowRight' ? 1 : -1
+				if (e.shiftKey && store.selectedItemIds.length) {
+					store.nudgeItems(store.selectedItemIds, direction * (e.altKey ? 1 : frameStep()))
+				} else {
+					store.seekTo(store.playheadSec + direction * (e.altKey ? 1 : frameStep()))
+				}
+				return
+			}
+			case 'Home':
+				e.preventDefault()
+				store.seekTo(0)
+				return
+			case 'End':
+				e.preventDefault()
+				store.seekTo(store.contentEnd)
+				return
+			case 'Delete':
+			case 'Backspace':
+				if (store.selectedItemIds.length) {
+					e.preventDefault()
+					store.deleteItems(store.selectedItemIds, { ripple: !e.shiftKey && !e.altKey })
+				}
+				return
+			case 'm':
+			case 'M':
+				e.preventDefault()
+				store.addMarker(store.playheadSec)
+				return
+			case '+':
+			case '=':
+				e.preventDefault()
+				zoomBy?.(1.25)
+				return
+			case '-':
+			case '_':
+				e.preventDefault()
+				zoomBy?.(0.8)
+				return
+			case 'Escape':
+				store.clearItemSelection()
+				return
+		}
+	}
+
+	onMounted(() => window.addEventListener('keydown', onKeyDown))
+	onUnmounted(() => window.removeEventListener('keydown', onKeyDown))
+}
diff --git a/src/renderer/src/editor/composables/useEdlPlayback.ts b/src/renderer/src/editor/composables/useEdlPlayback.ts
new file mode 100644
index 0000000..037214f
--- /dev/null
+++ b/src/renderer/src/editor/composables/useEdlPlayback.ts
@@ -0,0 +1,322 @@
+import { computed, onUnmounted, ref, watch, type Ref } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+
+interface EdlSegment {
+	itemId: string
+	tStart: number
+	tEnd: number
+	src: string
+	sourceIn: number
+	speed: number
+	muted: boolean
+	gain?: number
+	trackId?: string
+}
+
+/**
+ * EDL playback engine (PRD §5.3): plays the COMPOSED timeline through an
+ * A/B pair of <video> elements — one active/visible, one buffering the next
+ * segment. Gaps render black and advance on the rAF wall clock. All external
+ * seeks arrive via store.seekRequest; scrubbing while playing just re-seeks.
+ *
+ * Audio tracks play through a POOL of <audio> elements — one per audio track,
+ * created on demand — each slaved to the playhead. This lets every audio track
+ * sound in parallel with the video (which carries its own soundtrack), matching
+ * the multi-source amix that export produces (§5.9). The video EDL stays the
+ * master clock; each tick/seek repositions every audio element to match.
+ */
+export function useEdlPlayback(
+	videoA: Ref<HTMLVideoElement | null>,
+	videoB: Ref<HTMLVideoElement | null>
+) {
+	const store = useEditorStore()
+
+	const activeIsA = ref(true)
+	const inGap = ref(false)
+	const currentSegmentId = ref<string | null>(null)
+	const audioActive = ref(false)
+
+	// One <audio> element per audio track, created lazily. Attached to the DOM
+	// (hidden) rather than a bare `new Audio()` — Chromium plays in-document
+	// media more reliably and it keeps them inspectable.
+	const audioEls = new Map<string, HTMLAudioElement>()
+	const getAudioEl = (trackId: string): HTMLAudioElement => {
+		let el = audioEls.get(trackId)
+		if (!el) {
+			el = document.createElement('audio')
+			el.preload = 'auto'
+			el.dataset.edlAudioTrack = trackId
+			el.style.display = 'none'
+			document.body.appendChild(el)
+			audioEls.set(trackId, el)
+		}
+		return el
+	}
+
+	let rafId: number | null = null
+	let lastTick = 0
+	let suppressRafRead = false
+	let preloadedFor: string | null = null
+
+	const segments = computed<EdlSegment[]>(() => store.videoSegments as EdlSegment[])
+	const audioSegments = computed<EdlSegment[]>(() => store.audioSegments as EdlSegment[])
+	const hasContent = computed(() => segments.value.length > 0 || audioSegments.value.length > 0)
+
+	// Audio segments grouped by track — each track drives its own element.
+	const audioByTrack = computed<Map<string, EdlSegment[]>>(() => {
+		const m = new Map<string, EdlSegment[]>()
+		for (const s of audioSegments.value) {
+			const key = s.trackId || '_'
+			if (!m.has(key)) m.set(key, [])
+			m.get(key)!.push(s)
+		}
+		return m
+	})
+
+	// Which audio item each track element is currently locked onto. A track's
+	// element free-runs once started; we only hard-seek it on (re)entry to a
+	// segment, an explicit seek, or a large drift — NOT every frame, or the
+	// decoder never gets to play smoothly (it just stutters out "beats").
+	const activeAudioSeg = new Map<string, string>()
+	const AUDIO_DRIFT_HARD = 0.5
+
+	/**
+	 * Reposition every audio-track element for playhead `t`. Each track plays its
+	 * covering segment in parallel with the video; a track with no segment (or
+	 * muted) pauses. `force` re-seeks the element (segment change / explicit seek);
+	 * otherwise the element free-runs and is only nudged on large drift.
+	 */
+	const syncAudio = (t: number, force = false) => {
+		let anyActive = false
+		const seen = new Set<string>()
+		for (const [trackId, segs] of audioByTrack.value) {
+			seen.add(trackId)
+			const el = getAudioEl(trackId)
+			const seg = segs.find((s) => t >= s.tStart - 1e-6 && t < s.tEnd - 1e-6)
+			if (!seg || seg.muted) {
+				activeAudioSeg.delete(trackId)
+				if (!el.paused) el.pause()
+				continue
+			}
+			anyActive = true
+			const changed = activeAudioSeg.get(trackId) !== seg.itemId
+			// Compare against the src we LAST SET (raw), never el.src — reading
+			// el.src back returns a normalized/encoded URL (media:///Users →
+			// media://users, %20 for spaces) that never equals seg.src, which
+			// would reset .src every frame and reload the element into silence.
+			if (el.dataset.edlSrc !== seg.src) {
+				el.src = seg.src
+				el.dataset.edlSrc = seg.src
+			}
+			el.playbackRate = seg.speed
+			el.volume = Math.max(0, Math.min(1, seg.gain ?? 1))
+			const target = seg.sourceIn + (t - seg.tStart) * seg.speed
+			if (changed || force || Math.abs(el.currentTime - target) > AUDIO_DRIFT_HARD) {
+				el.currentTime = target
+			}
+			activeAudioSeg.set(trackId, seg.itemId)
+			if (store.isPlaying) {
+				if (el.paused) el.play().catch(() => { })
+			} else if (!el.paused) {
+				el.pause()
+			}
+		}
+		// Pause elements whose track is gone (deleted/hidden this frame).
+		for (const [trackId, el] of audioEls) {
+			if (!seen.has(trackId)) {
+				activeAudioSeg.delete(trackId)
+				if (!el.paused) el.pause()
+			}
+		}
+		audioActive.value = anyActive
+	}
+
+	const activeEl = () => (activeIsA.value ? videoA.value : videoB.value)
+	const bufferEl = () => (activeIsA.value ? videoB.value : videoA.value)
+
+	const segmentAt = (t: number): EdlSegment | null =>
+		segments.value.find((s) => t >= s.tStart - 1e-6 && t < s.tEnd - 1e-6) || null
+
+	const nextSegmentAfter = (t: number): EdlSegment | null =>
+		segments.value.find((s) => s.tStart >= t - 1e-6) || null
+
+	/** Earliest start across video + audio segments (content may be audio-only). */
+	const firstStart = (): number => {
+		const starts = [...segments.value, ...audioSegments.value].map((s) => s.tStart)
+		return starts.length ? Math.min(...starts) : 0
+	}
+
+	const sourceTime = (t: number, seg: EdlSegment) =>
+		seg.sourceIn + (t - seg.tStart) * seg.speed
+
+	const applySegmentToEl = (el: HTMLVideoElement, seg: EdlSegment, t: number) => {
+		const wantedSrc = seg.src
+		if (el.src !== wantedSrc) {
+			el.src = wantedSrc
+			preloadedFor = null
+		}
+		el.playbackRate = seg.speed
+		el.muted = seg.muted
+		const target = sourceTime(t, seg)
+		if (Math.abs(el.currentTime - target) > 0.08) {
+			el.currentTime = target
+		}
+	}
+
+	/** Activate the segment covering time t on the active element. */
+	const activateAt = (t: number) => {
+		const seg = segmentAt(t)
+		inGap.value = !seg
+		if (!seg) {
+			currentSegmentId.value = null
+			activeEl()?.pause()
+			return
+		}
+		const el = activeEl()
+		if (!el) return
+
+		// If the buffer element was preloaded for this segment, swap instead
+		if (currentSegmentId.value !== seg.itemId) {
+			const buf = bufferEl()
+			if (buf && preloadedFor === seg.itemId) {
+				activeIsA.value = !activeIsA.value
+				el.pause()
+				preloadedFor = null
+				applySegmentToEl(buf, seg, t)
+				currentSegmentId.value = seg.itemId
+				if (store.isPlaying) buf.play().catch(() => { })
+				return
+			}
+		}
+
+		applySegmentToEl(el, seg, t)
+		currentSegmentId.value = seg.itemId
+		if (store.isPlaying && el.paused) el.play().catch(() => { })
+	}
+
+	/** Prime the buffer element with the next segment's source. */
+	const maybePreload = (t: number) => {
+		const seg = segmentAt(t)
+		if (!seg) return
+		if (seg.tEnd - t > 1.5) return
+		const next = nextSegmentAfter(seg.tEnd)
+		if (!next || next.itemId === seg.itemId || preloadedFor === next.itemId) return
+		const buf = bufferEl()
+		if (!buf) return
+		buf.src = next.src
+		buf.playbackRate = next.speed
+		buf.muted = next.muted
+		buf.currentTime = next.sourceIn
+		buf.pause()
+		preloadedFor = next.itemId
+	}
+
+	// ---------- rAF loop ----------
+	const tick = (now: number) => {
+		rafId = requestAnimationFrame(tick)
+		const dt = (now - lastTick) / 1000
+		lastTick = now
+		if (!store.isPlaying) return
+
+		const seg = segmentAt(store.playheadSec)
+		if (seg) {
+			inGap.value = false
+			const el = activeEl()
+			if (!el) return
+			if (currentSegmentId.value !== seg.itemId) {
+				activateAt(store.playheadSec)
+				return
+			}
+			if (el.paused) el.play().catch(() => { })
+			if (!suppressRafRead) {
+				// Derive the playhead from real media time (drift-free)
+				store.playheadSec = seg.tStart + (el.currentTime - seg.sourceIn) / seg.speed
+			}
+			suppressRafRead = false
+			// Crossed the segment end?
+			if (store.playheadSec >= seg.tEnd - 0.02) {
+				store.playheadSec = seg.tEnd
+				activateAt(seg.tEnd + 1e-3)
+			}
+			maybePreload(store.playheadSec)
+		} else {
+			// No video at the playhead: advance on the wall clock (audio-track
+			// items, if any, are heard via the slaved <audio> element). Black
+			// frame until a video segment begins; stop at the sequence end.
+			inGap.value = true
+			activeEl()?.pause()
+			currentSegmentId.value = null
+			if (store.playheadSec >= store.contentEnd - 1e-3) {
+				store.isPlaying = false
+				store.playheadSec = store.contentEnd
+				return
+			}
+			const advanced = Math.min(store.playheadSec + dt, store.contentEnd)
+			store.playheadSec = advanced
+			// Entered a video segment? make it active.
+			if (segmentAt(advanced)) activateAt(advanced)
+		}
+	}
+
+	// ---------- reactions ----------
+	// Audio elements free-run during playback: a plain playhead advance must NOT
+	// re-seek them (that stutters the decoder). Only align on segment entry or a
+	// real drift — handled inside syncAudio with force=false.
+	watch(() => store.playheadSec, (t) => syncAudio(t, false))
+
+	watch(() => store.isPlaying, (playing) => {
+		if (playing) {
+			// Restart from the top if at the very end
+			if (store.playheadSec >= store.contentEnd - 0.05 && hasContent.value) {
+				store.playheadSec = firstStart()
+			}
+			activateAt(store.playheadSec)
+		} else {
+			activeEl()?.pause()
+		}
+		// Force-anchor audio to the playhead on play/pause transitions.
+		syncAudio(store.playheadSec, true)
+	})
+
+	watch(() => store.seekRequest, (req) => {
+		suppressRafRead = true
+		activateAt(req.time)
+		syncAudio(req.time, true) // explicit seek: re-anchor audio
+	})
+
+	// Timeline edits can change/remove the current segment — re-resolve.
+	// Watch a content FINGERPRINT, not array identity: unrelated doc changes
+	// (e.g. adding an overlay track) rebuild the computed array every time and
+	// must not trigger a needless re-seek/frame jump.
+	watch(() => JSON.stringify(segments.value) + '|' + JSON.stringify(audioSegments.value), () => {
+		if (!store.isPlaying) {
+			activateAt(store.playheadSec)
+			syncAudio(store.playheadSec, true)
+		}
+	})
+
+	const start = () => {
+		lastTick = performance.now()
+		rafId = requestAnimationFrame(tick)
+		activateAt(store.playheadSec)
+	}
+
+	onUnmounted(() => {
+		if (rafId !== null) cancelAnimationFrame(rafId)
+		for (const el of audioEls.values()) {
+			el.pause()
+			el.src = ''
+			el.remove()
+		}
+		audioEls.clear()
+	})
+
+	return {
+		activeIsA,
+		inGap,
+		audioActive,
+		hasContent,
+		currentSegmentId,
+		start
+	}
+}
diff --git a/src/renderer/src/editor/composables/useTimelineInteractions.ts b/src/renderer/src/editor/composables/useTimelineInteractions.ts
new file mode 100644
index 0000000..75f905f
--- /dev/null
+++ b/src/renderer/src/editor/composables/useTimelineInteractions.ts
@@ -0,0 +1,303 @@
+import { ref } from 'vue'
+import type { TimelineItem } from '@shared/types'
+import type { TimelineState } from '@shared/timeline'
+import { itemEnd, itemDuration, MIN_ITEM_DURATION } from '@shared/timeline'
+import { useEditorStore } from '../../stores/editorStore'
+import type { TimelineViewport } from './useTimelineViewport'
+
+type GestureMode = 'idle' | 'movingItem' | 'trimmingEdge' | 'scrubbing'
+
+/**
+ * Pointer-Events state machine for all timeline gestures (PRD §5.6):
+ * move (with snapping + cross-track), trim (edge drag, Alt = ripple-trim),
+ * and ruler/playhead scrubbing. Mutates the reactive doc live during the
+ * gesture; commits exactly ONE history step on pointerup by diffing against
+ * the snapshot taken at pointerdown. Escape restores the snapshot.
+ */
+export function useTimelineInteractions(viewport: TimelineViewport) {
+	const store = useEditorStore()
+
+	const mode = ref<GestureMode>('idle')
+	const snapGuideSec = ref<number | null>(null)
+	const activeItemId = ref<string | null>(null)
+
+	const SNAP_THRESHOLD_PX = 8
+
+	let gestureBefore: TimelineState | null = null
+	let grabOffsetSec = 0            // pointer offset inside the item on move-start
+	let trimEdge: 'left' | 'right' = 'left'
+	let trimRipple = false
+	let laneRects: Array<{ trackId: string; top: number; bottom: number }> = []
+
+	const doc = () => store.doc!
+
+	const item = (): TimelineItem | undefined =>
+		doc().timeline.find((i) => i.id === activeItemId.value)
+
+	// ---------- snapping ----------
+	const snapCandidates = (ignoreId?: string): number[] => {
+		const times: number[] = [0, store.playheadSec]
+		for (const m of store.markers) times.push(m.time)
+		for (const other of doc().timeline) {
+			if (other.id === ignoreId) continue
+			times.push(other.timelineStart, itemEnd(other))
+		}
+		return times
+	}
+
+	const applySnap = (t: number, ignoreId?: string): number => {
+		snapGuideSec.value = null
+		if (!store.snapEnabled) return t
+		const threshold = viewport.pxToSec(SNAP_THRESHOLD_PX)
+		let best: number | null = null
+		let bestDist = threshold
+		for (const candidate of snapCandidates(ignoreId)) {
+			const dist = Math.abs(candidate - t)
+			if (dist <= bestDist) {
+				best = candidate
+				bestDist = dist
+			}
+		}
+		if (best !== null) snapGuideSec.value = best
+		return best ?? t
+	}
+
+	// ---------- shared gesture plumbing ----------
+	const attach = () => {
+		window.addEventListener('pointermove', onPointerMove)
+		window.addEventListener('pointerup', onPointerUp)
+		window.addEventListener('keydown', onKeyDown)
+	}
+
+	const detach = () => {
+		window.removeEventListener('pointermove', onPointerMove)
+		window.removeEventListener('pointerup', onPointerUp)
+		window.removeEventListener('keydown', onKeyDown)
+		snapGuideSec.value = null
+	}
+
+	const cancelGesture = () => {
+		if (gestureBefore && store.doc) {
+			store.doc.tracks = gestureBefore.tracks
+			store.doc.timeline = gestureBefore.timeline
+		}
+		gestureBefore = null
+		activeItemId.value = null
+		mode.value = 'idle'
+		detach()
+	}
+
+	const onKeyDown = (e: KeyboardEvent) => {
+		if (e.key === 'Escape' && mode.value !== 'idle') {
+			e.stopPropagation()
+			cancelGesture()
+		}
+	}
+
+	const pointerToTime = (e: PointerEvent): number => {
+		const el = viewport.scrollEl.value
+		if (!el) return 0
+		const rect = el.getBoundingClientRect()
+		return viewport.pxToSec(el.scrollLeft + (e.clientX - rect.left))
+	}
+
+	const captureLaneRects = () => {
+		const el = viewport.scrollEl.value
+		if (!el) return
+		laneRects = Array.from(el.querySelectorAll<HTMLElement>('[data-track-id]')).map((lane) => {
+			const rect = lane.getBoundingClientRect()
+			return { trackId: lane.dataset.trackId!, top: rect.top, bottom: rect.bottom }
+		})
+	}
+
+	const trackAtY = (clientY: number): string | null => {
+		const hit = laneRects.find((l) => clientY >= l.top && clientY <= l.bottom)
+		return hit?.trackId || null
+	}
+
+	// ---------- move ----------
+	const beginMove = (itemId: string, e: PointerEvent) => {
+		const target = doc().timeline.find((i) => i.id === itemId)
+		const track = doc().tracks.find((t) => t.id === target?.trackId)
+		if (!target || !track || track.locked) return
+		mode.value = 'movingItem'
+		activeItemId.value = itemId
+		gestureBefore = JSON.parse(JSON.stringify({ tracks: doc().tracks, timeline: doc().timeline }))
+		grabOffsetSec = pointerToTime(e) - target.timelineStart
+		captureLaneRects()
+		;(e.target as HTMLElement).setPointerCapture?.(e.pointerId)
+		attach()
+	}
+
+	const overlaps = (target: TimelineItem, trackId: string, start: number): boolean => {
+		const end = start + itemDuration(target)
+		return doc().timeline.some(
+			(other) => other.id !== target.id && other.trackId === trackId &&
+				start < itemEnd(other) && end > other.timelineStart
+		)
+	}
+
+	const moveTick = (e: PointerEvent) => {
+		const target = item()
+		if (!target) return
+		let start = applySnap(Math.max(0, pointerToTime(e) - grabOffsetSec), target.id)
+
+		// Cross-track: pointer Y picks the lane; validate kind + locked/hidden
+		const candidateTrackId = trackAtY(e.clientY)
+		let trackId = target.trackId
+		if (candidateTrackId && candidateTrackId !== target.trackId) {
+			const candidateTrack = doc().tracks.find((t) => t.id === candidateTrackId)
+			const sourceKind = doc().media.find((a) => a.id === target.sourceAssetId)?.kind || 'video'
+			const currentKind = doc().tracks.find((t) => t.id === target.trackId)?.kind
+			if (candidateTrack && !candidateTrack.locked && !candidateTrack.hidden &&
+				candidateTrack.kind === currentKind && (candidateTrack.kind === 'video' || candidateTrack.kind === sourceKind)) {
+				trackId = candidateTrackId
+			}
+		}
+
+		// Overlap forbidden: clamp against the nearer neighbor on the target track
+		if (overlaps(target, trackId, start)) {
+			const dur = itemDuration(target)
+			const neighbors = doc().timeline
+				.filter((o) => o.id !== target.id && o.trackId === trackId)
+				.sort((a, b) => a.timelineStart - b.timelineStart)
+			// Find the gap the pointer is in and clamp into it if it fits
+			let placed = false
+			let prevEnd = 0
+			for (const n of neighbors) {
+				if (start + dur <= n.timelineStart && start >= prevEnd) { placed = true; break }
+				if (start < n.timelineStart) {
+					// try clamping into [prevEnd, n.start]
+					if (n.timelineStart - prevEnd >= dur) {
+						start = Math.min(Math.max(start, prevEnd), n.timelineStart - dur)
+						placed = true
+					}
+					break
+				}
+				prevEnd = itemEnd(n)
+			}
+			if (!placed) {
+				if (!overlaps(target, trackId, Math.max(start, prevEnd))) {
+					start = Math.max(start, prevEnd)
+				} else {
+					return // no room — leave item where it was this tick
+				}
+			}
+		}
+
+		target.trackId = trackId
+		target.timelineStart = start
+	}
+
+	// ---------- trim ----------
+	const beginTrim = (itemId: string, edge: 'left' | 'right', e: PointerEvent) => {
+		const target = doc().timeline.find((i) => i.id === itemId)
+		const track = doc().tracks.find((t) => t.id === target?.trackId)
+		if (!target || !track || track.locked) return
+		mode.value = 'trimmingEdge'
+		activeItemId.value = itemId
+		trimEdge = edge
+		trimRipple = e.altKey
+		gestureBefore = JSON.parse(JSON.stringify({ tracks: doc().tracks, timeline: doc().timeline }))
+		captureLaneRects()
+		;(e.target as HTMLElement).setPointerCapture?.(e.pointerId)
+		attach()
+	}
+
+	const trimTick = (e: PointerEvent) => {
+		const target = item()
+		if (!target) return
+		const asset = doc().media.find((a) => a.id === target.sourceAssetId)
+		const sourceDuration = asset?.metadata?.duration ?? Number.POSITIVE_INFINITY
+		const speed = target.speed || 1
+		const t = applySnap(pointerToTime(e), target.id)
+		const before = gestureBefore!.timeline.find((i) => i.id === target.id)!
+		const oldDuration = itemDuration(target)
+
+		if (trimEdge === 'left') {
+			// Moving the left edge changes timelineStart AND in together
+			const maxStart = target.timelineStart + itemDuration(target) - MIN_ITEM_DURATION
+			let newStart = Math.min(Math.max(0, t), maxStart)
+			// Clamp against the left neighbor ALWAYS (ripple shifts downstream
+			// items, but the item's own start must never overlap its predecessor)
+			const leftNeighborEnd = doc().timeline
+				.filter((o) => o.id !== target.id && o.trackId === target.trackId && itemEnd(o) <= before.timelineStart + 1e-6)
+				.reduce((max, o) => Math.max(max, itemEnd(o)), 0)
+			newStart = Math.max(newStart, leftNeighborEnd)
+			const newIn = target.in + (newStart - target.timelineStart) * speed
+			if (newIn < 0) return
+			target.in = newIn
+			target.timelineStart = newStart
+			target.duration = (target.out - target.in) / speed
+		} else {
+			// Moving the right edge changes out
+			const minEnd = target.timelineStart + MIN_ITEM_DURATION
+			let newEnd = Math.max(t, minEnd)
+			if (!trimRipple) {
+				const rightNeighborStart = doc().timeline
+					.filter((o) => o.id !== target.id && o.trackId === target.trackId && o.timelineStart >= itemEnd(before) - 1e-6)
+					.reduce((min, o) => Math.min(min, o.timelineStart), Number.POSITIVE_INFINITY)
+				newEnd = Math.min(newEnd, rightNeighborStart)
+			}
+			const newOut = target.in + (newEnd - target.timelineStart) * speed
+			if (newOut > sourceDuration + 0.01) return
+			target.out = newOut
+			target.duration = (target.out - target.in) / speed
+		}
+
+		// Ripple-trim: shift downstream items by the duration delta
+		if (trimRipple) {
+			const delta = itemDuration(target) - oldDuration
+			if (Math.abs(delta) > 1e-9) {
+				for (const other of doc().timeline) {
+					if (other.id !== target.id && other.trackId === target.trackId &&
+						other.timelineStart > before.timelineStart) {
+						other.timelineStart = Math.max(0, other.timelineStart + delta)
+					}
+				}
+			}
+		}
+	}
+
+	// ---------- scrub ----------
+	const beginScrub = (e: PointerEvent) => {
+		mode.value = 'scrubbing'
+		;(e.target as HTMLElement).setPointerCapture?.(e.pointerId)
+		store.seekTo(Math.max(0, pointerToTime(e)))
+		attach()
+	}
+
+	// ---------- global handlers ----------
+	const onPointerMove = (e: PointerEvent) => {
+		switch (mode.value) {
+			case 'movingItem': moveTick(e); break
+			case 'trimmingEdge': trimTick(e); break
+			case 'scrubbing': store.seekTo(Math.max(0, pointerToTime(e))); break
+		}
+	}
+
+	const onPointerUp = () => {
+		if (mode.value === 'movingItem' || mode.value === 'trimmingEdge') {
+			if (gestureBefore) {
+				const label = mode.value === 'movingItem' ? 'Move' : (trimRipple ? 'Ripple trim' : 'Trim')
+				store.commitStep({ before: gestureBefore, label })
+			}
+		}
+		gestureBefore = null
+		activeItemId.value = null
+		mode.value = 'idle'
+		detach()
+	}
+
+	return {
+		mode,
+		snapGuideSec,
+		activeItemId,
+		beginMove,
+		beginTrim,
+		beginScrub,
+		cancelGesture
+	}
+}
+
+export type TimelineInteractions = ReturnType<typeof useTimelineInteractions>
diff --git a/src/renderer/src/editor/composables/useTimelineViewport.ts b/src/renderer/src/editor/composables/useTimelineViewport.ts
new file mode 100644
index 0000000..64d7c25
--- /dev/null
+++ b/src/renderer/src/editor/composables/useTimelineViewport.ts
@@ -0,0 +1,130 @@
+import { computed, nextTick, ref, type InjectionKey, type Ref } from 'vue'
+import { useEditorStore } from '../../stores/editorStore'
+
+/**
+ * Viewport math for the purpose-built timeline: px <-> seconds, scroll
+ * tracking, window-mounting range, and cursor-anchored zoom.
+ * Instantiated ONCE by TimelinePanel and provided to lanes/ruler/clips.
+ */
+export function useTimelineViewport() {
+	const store = useEditorStore()
+
+	const scrollEl = ref<HTMLElement | null>(null)
+	const scrollLeft = ref(0)
+	const clientWidth = ref(0)
+
+	const MIN_PX_PER_SEC = 4
+	const MAX_PX_PER_SEC = 400
+	const VISIBLE_MARGIN_SEC = 5
+
+	const secToPx = (s: number) => s * store.pxPerSecond
+	const pxToSec = (p: number) => p / store.pxPerSecond
+
+	/** Total content width: sequence end + tail head-room for appending. */
+	const contentWidth = computed(() => secToPx(store.contentEnd + store.timelineTail))
+
+	/** Seconds range currently visible (with margin) — drives window-mounting. */
+	const visibleRange = computed<[number, number]>(() => [
+		pxToSec(scrollLeft.value) - VISIBLE_MARGIN_SEC,
+		pxToSec(scrollLeft.value + clientWidth.value) + VISIBLE_MARGIN_SEC
+	])
+
+	const intersectsVisible = (startSec: number, endSec: number) =>
+		endSec >= visibleRange.value[0] && startSec <= visibleRange.value[1]
+
+	const onScroll = () => {
+		if (!scrollEl.value) return
+		scrollLeft.value = scrollEl.value.scrollLeft
+		clientWidth.value = scrollEl.value.clientWidth
+	}
+
+	const setScrollEl = (el: HTMLElement | null) => {
+		scrollEl.value = el
+		onScroll()
+	}
+
+	const clampZoom = (v: number) => Math.min(MAX_PX_PER_SEC, Math.max(MIN_PX_PER_SEC, v))
+
+	/** Zoom keeping the time under the cursor fixed in place. */
+	const zoomAtCursor = async (e: WheelEvent) => {
+		const el = scrollEl.value
+		if (!el) return
+		const rect = el.getBoundingClientRect()
+		const offsetX = e.clientX - rect.left
+		const cursorTime = pxToSec(el.scrollLeft + offsetX)
+		store.pxPerSecond = clampZoom(store.pxPerSecond * Math.exp(-e.deltaY * 0.002))
+		await nextTick() // content width updates first
+		el.scrollLeft = cursorTime * store.pxPerSecond - offsetX
+		onScroll()
+	}
+
+	/** Zoom by a factor, anchored at the viewport center. */
+	const zoomBy = async (factor: number) => {
+		const el = scrollEl.value
+		if (!el) return
+		const centerTime = pxToSec(el.scrollLeft + el.clientWidth / 2)
+		store.pxPerSecond = clampZoom(store.pxPerSecond * factor)
+		await nextTick()
+		el.scrollLeft = centerTime * store.pxPerSecond - el.clientWidth / 2
+		onScroll()
+	}
+
+	const fitToWindow = async () => {
+		const el = scrollEl.value
+		if (!el) return
+		store.pxPerSecond = clampZoom(el.clientWidth / Math.max(store.contentEnd, 1))
+		await nextTick()
+		el.scrollLeft = 0
+		onScroll()
+	}
+
+	const fitToSelection = async () => {
+		const el = scrollEl.value
+		const items = store.selectedItems
+		if (!el || !items.length) return
+		const minStart = Math.min(...items.map((i) => i.timelineStart))
+		const maxEnd = Math.max(...items.map((i) => i.timelineStart + i.duration))
+		const span = Math.max(maxEnd - minStart, 0.5)
+		store.pxPerSecond = clampZoom((el.clientWidth * 0.9) / span)
+		await nextTick()
+		el.scrollLeft = minStart * store.pxPerSecond - el.clientWidth * 0.05
+		onScroll()
+	}
+
+	const scrollToTime = (t: number) => {
+		const el = scrollEl.value
+		if (!el) return
+		const px = secToPx(t)
+		if (px < el.scrollLeft || px > el.scrollLeft + el.clientWidth) {
+			el.scrollLeft = Math.max(0, px - el.clientWidth / 3)
+			onScroll()
+		}
+	}
+
+	return {
+		scrollEl,
+		scrollLeft,
+		clientWidth,
+		secToPx,
+		pxToSec,
+		contentWidth,
+		visibleRange,
+		intersectsVisible,
+		setScrollEl,
+		onScroll,
+		zoomAtCursor,
+		zoomBy,
+		fitToWindow,
+		fitToSelection,
+		scrollToTime
+	}
+}
+
+export type TimelineViewport = ReturnType<typeof useTimelineViewport>
+export const TimelineViewportKey: InjectionKey<TimelineViewport> = Symbol('timeline-viewport')
+export const TimelineInteractionsKey: InjectionKey<any> = Symbol('timeline-interactions')
+
+/** Convenience for template width/left styles. */
+export const px = (n: number) => `${n}px`
+
+export type MaybeElement = Ref<HTMLElement | null>
diff --git a/src/renderer/src/editor/utils/revisionThumbs.ts b/src/renderer/src/editor/utils/revisionThumbs.ts
new file mode 100644
index 0000000..d218630
--- /dev/null
+++ b/src/renderer/src/editor/utils/revisionThumbs.ts
@@ -0,0 +1,31 @@
+import type { EditorDocument, EditorRevision } from '@shared/types'
+
+/**
+ * Resolves up to `count` thumbnail URLs for a revision card by mapping the
+ * snapshot's first timeline items back to their source clips' already-on-disk
+ * scene JPGs (media://). Returns [] when nothing resolves — callers render a
+ * placeholder block.
+ */
+export function revisionThumbs(revision: EditorRevision, doc: EditorDocument | null, count = 1): string[] {
+	if (!doc) return []
+	const items = [...revision.snapshot.timeline].sort((a, b) => a.timelineStart - b.timelineStart)
+	const thumbs: string[] = []
+	for (const item of items) {
+		if (thumbs.length >= count) break
+		const asset = doc.media.find((a) => a.id === item.sourceAssetId)
+		const clip = asset?.clips.find((c) => c.id === item.sourceClipId)
+		if (clip?.thumbnailPath) thumbs.push(`media://${clip.thumbnailPath}`)
+	}
+	return thumbs
+}
+
+export function relativeTime(timestamp: number): string {
+	const delta = Date.now() - timestamp
+	const minutes = Math.floor(delta / 60000)
+	if (minutes < 1) return 'just now'
+	if (minutes < 60) return `${minutes}m ago`
+	const hours = Math.floor(minutes / 60)
+	if (hours < 24) return `${hours}h ago`
+	const days = Math.floor(hours / 24)
+	return `${days}d ago`
+}
diff --git a/src/renderer/src/pages/HomePage.vue b/src/renderer/src/pages/HomePage.vue
index 4ed645d..2801c96 100644
--- a/src/renderer/src/pages/HomePage.vue
+++ b/src/renderer/src/pages/HomePage.vue
@@ -21,8 +21,8 @@
 					/>
 
 					<!-- New Image Edit Card -->
-					<NewThreadCard 
-						title="New Image Edit" 
+					<NewThreadCard
+						title="New Image Edit"
 						description="Create stunning visuals from your image collection"
 						@click="handleCreateImageEdit"
 					>
@@ -33,6 +33,19 @@
 						</template>
 					</NewThreadCard>
 
+					<!-- Video Editor Card -->
+					<NewThreadCard
+						title="Video Editor"
+						description="Cut and arrange clips on a multi-track timeline"
+						@click="handleCreateEditorProject"
+					>
+						<template #icon>
+							<svg xmlns="http://www.w3.org/2000/svg" class="w-6 h-6" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+								<rect x="3" y="5" width="18" height="4" rx="1"/><rect x="3" y="12" width="12" height="4" rx="1"/><line x1="8" y1="3" x2="8" y2="21"/>
+							</svg>
+						</template>
+					</NewThreadCard>
+
 					<ThreadCard v-for="(thread, index) in videoStore.threads" :key="thread.id" :thread="thread"
 						@open="openThread" @delete="handleDeleteThread" />
 				</div>
@@ -55,7 +68,16 @@ const videoStore = useVideoStore()
 const loading = ref(true)
 
 const openThread = (id: string) => {
-	router.push(`/chat/${id}`)
+	const thread = videoStore.threads.find((t) => t.id === id)
+	router.push(thread?.type === 'editor' ? `/editor/${id}` : `/chat/${id}`)
+}
+
+const handleCreateEditorProject = async () => {
+	const thread = await (window as any).api.createEditorProject('Untitled Project')
+	if (thread) {
+		videoStore.threads.unshift(thread)
+		router.push(`/editor/${thread.id}`)
+	}
 }
 
 const handleCreateImageEdit = async () => {
diff --git a/src/renderer/src/router.ts b/src/renderer/src/router.ts
index de97675..f53b6ee 100644
--- a/src/renderer/src/router.ts
+++ b/src/renderer/src/router.ts
@@ -5,6 +5,7 @@ import SettingsPage from './pages/SettingsPage.vue'
 import HomePage from './pages/HomePage.vue'
 
 import GraphChatPage from './pages/GraphChatPage.vue'
+import VideoEditorPage from './editor/VideoEditorPage.vue'
 
 const routes = [
 	{
@@ -28,6 +29,11 @@ const routes = [
 		name: 'chat',
 		component: GraphChatPage
 	},
+	{
+		path: '/editor/:id',
+		name: 'editor',
+		component: VideoEditorPage
+	},
 
 	{
 		path: '/settings',
diff --git a/src/renderer/src/stores/editorStore.ts b/src/renderer/src/stores/editorStore.ts
new file mode 100644
index 0000000..9cba456
--- /dev/null
+++ b/src/renderer/src/stores/editorStore.ts
@@ -0,0 +1,1866 @@
+import { defineStore } from 'pinia'
+import { ref, computed, watch } from 'vue'
+import type {
+	BackgroundTask, Clip, EditorDocument, EditorHistoryStep, EditorMarker,
+	EditorPersona, EditorRevision, MediaAsset, PromptTurn, Thread, TimelineDiff,
+	TimelineItem, TimelineSnapshot, Track
+} from '@shared/types'
+import {
+	applyTimelineDiff, clampSpeed, clipToItem, computeContentEnd,
+	diffTimelines, itemDuration, itemEnd, itemFromAsset, repairOverlaps,
+	type TimelineState
+} from '@shared/timeline'
+import { computeScope } from '@shared/ai-scope'
+
+/**
+ * Store for the timeline video editor (/editor/:id).
+ *
+ * Ownership split (prevents autosave <-> thread-updated echo clobbering):
+ * - MAIN owns preprocessing-derived asset fields: preprocessing, proxyPath,
+ *   metadata, preprocessState, preprocessError, clips content.
+ * - RENDERER owns: selection, clip.selected flags, tracks, timeline,
+ *   timelineMeta, activePersonaId, customPersonas.
+ * persistDoc() sends only renderer-owned fields; the thread-updated handler
+ * merges only main-owned fields.
+ */
+export const useEditorStore = defineStore('editor', () => {
+	const api = (window as any).api
+
+	// ===== State =====
+	const threadId = ref<string | null>(null)
+	const thread = ref<Thread | null>(null)
+	const doc = ref<EditorDocument | null>(null)
+	const backgroundTasks = ref<Record<string, BackgroundTask>>({})
+	const selectedAssetId = ref<string | null>(null)
+	const selectedClipId = ref<string | null>(null)
+	const urlImports = ref<Record<string, { url: string; percent: number }>>({})
+	const interruptedAssets = ref<Set<string>>(new Set())
+	const dirty = ref(false)
+	const saveInFlight = ref(false)
+	const deps = ref<{ ffmpeg: boolean; scenedetect: boolean; ytDlp: boolean }>({
+		ffmpeg: true,
+		scenedetect: true,
+		ytDlp: true
+	})
+	const loading = ref(false)
+
+	// ===== Timeline view state (M2) =====
+	const playheadSec = ref(0)
+	const isPlaying = ref(false)
+	const pxPerSecond = ref(40)
+	const timelineView = ref<'filmstrip' | 'context'>('filmstrip')
+	const snapEnabled = ref(true)
+	// Incremented on every external seek; the playback engine watches it.
+	const seekRequest = ref<{ n: number; time: number }>({ n: 0, time: 0 })
+	const selectedItemIds = ref<string[]>([])
+
+	// ===== History state (M2) =====
+	const historySteps = ref<EditorHistoryStep[]>([])
+	let pushCounter = 0
+
+	// ===== Personas (M3) =====
+	const personas = ref<EditorPersona[]>([]) // built-ins + global user library (from main)
+	const DEFAULT_PERSONA_ID = 'podcast-editor'
+
+	// ===== AI prompt turns (M3, reworked for revisions) =====
+	const activeTurnId = ref<string | null>(null)
+	const lastAnswer = ref<{ turnId: string; text: string } | null>(null)
+	const promptError = ref<string | null>(null)
+	const scopeWiden = ref<'auto' | 'chapter' | 'full'>('auto')
+
+	// ===== Revision tree =====
+	const revisions = ref<EditorRevision[]>([])
+
+	/** Result card data for the most recent APPLIED AI edit (already a revision). */
+	interface AiResult {
+		turnId: string
+		revisionId: string
+		revisionSeq: number
+		parentRevisionId: string | null
+		counts: { added: number; removed: number; updated: number; markers: number }
+		rationale?: string
+		droppedOps: string[]
+		scopeLabel?: string
+		thinContext: boolean
+		truncated: boolean
+	}
+	const lastResult = ref<AiResult | null>(null)
+
+	// ===== Export / render (M4) =====
+	const renderState = ref<{
+		renderId: string
+		percent: number
+		phase: 'rendering' | 'stitching' | 'done' | 'error'
+		outputPath?: string
+		error?: string
+	} | null>(null)
+
+	let autosaveTimer: ReturnType<typeof setTimeout> | null = null
+
+	// ===== Computeds =====
+	const assets = computed<MediaAsset[]>(() => doc.value?.media ?? [])
+	const isEmpty = computed(() => assets.value.length === 0)
+
+	const selectedAsset = computed(() =>
+		assets.value.find((a) => a.id === selectedAssetId.value) || null
+	)
+
+	const selectedClip = computed<Clip | null>(() => {
+		if (!selectedClipId.value) return null
+		for (const asset of assets.value) {
+			const clip = asset.clips.find((c) => c.id === selectedClipId.value)
+			if (clip) return clip
+		}
+		return null
+	})
+
+	const STEP_ORDER = ['proxy', 'scenes', 'thumbnails', 'descriptions']
+
+	const assetTasks = (assetId: string): BackgroundTask[] => {
+		const prefix = `${assetId}:`
+		return Object.entries(backgroundTasks.value)
+			.filter(([id]) => id.startsWith(prefix))
+			.map(([, task]) => task)
+			.sort((a, b) => {
+				const stepOf = (t: BackgroundTask) => STEP_ORDER.indexOf(t.id.split(':')[1] || '')
+				return stepOf(a) - stepOf(b)
+			})
+	}
+
+	const assetProgress = (assetId: string): { step: string; percent: number } | null => {
+		const running = assetTasks(assetId).find((t) => t.state === 'running')
+		if (!running) return null
+		return { step: running.id.split(':')[1] || running.name, percent: running.progress ?? 0 }
+	}
+
+	// ===== Timeline computeds (M2) =====
+	const sortedTracks = computed<Track[]>(() =>
+		[...(doc.value?.tracks || [])].sort((a, b) => a.order - b.order)
+	)
+
+	const itemsByTrack = computed<Record<string, TimelineItem[]>>(() => {
+		const map: Record<string, TimelineItem[]> = {}
+		for (const track of sortedTracks.value) map[track.id] = []
+		for (const item of doc.value?.timeline || []) {
+			(map[item.trackId] ||= []).push(item)
+		}
+		for (const id of Object.keys(map)) {
+			map[id].sort((a, b) => a.timelineStart - b.timelineStart)
+		}
+		return map
+	})
+
+	const contentEnd = computed(() => computeContentEnd(doc.value?.timeline || []))
+	const timelineTail = computed(() => Math.max(60, 0.25 * contentEnd.value))
+
+	const markers = computed<EditorMarker[]>(() => doc.value?.markers || [])
+
+	const selectedItems = computed<TimelineItem[]>(() =>
+		(doc.value?.timeline || []).filter((i) => selectedItemIds.value.includes(i.id))
+	)
+
+	/** Ordered playable segments for EDL preview (unhidden video tracks). */
+	const videoSegments = computed(() => {
+		if (!doc.value) return []
+		const hiddenOrVideoless = new Set(
+			doc.value.tracks.filter((t) => t.kind !== 'video' || t.hidden).map((t) => t.id)
+		)
+		const trackMuted = new Map(doc.value.tracks.map((t) => [t.id, t.muted]))
+		const assetById = new Map(doc.value.media.map((a) => [a.id, a]))
+
+		return doc.value.timeline
+			.filter((item) => !hiddenOrVideoless.has(item.trackId))
+			.sort((a, b) => a.timelineStart - b.timelineStart)
+			.flatMap((item) => {
+				const asset = assetById.get(item.sourceAssetId)
+				const src = asset ? (asset.proxyPath || asset.originalPath) : null
+				if (!src) return []
+				return [{
+					itemId: item.id,
+					tStart: item.timelineStart,
+					tEnd: itemEnd(item),
+					src: `media://${src}`,
+					sourceIn: item.in,
+					speed: item.speed || 1,
+					muted: !!item.muted || !!trackMuted.get(item.trackId)
+				}]
+			})
+	})
+
+	// Audio-track segments for preview (PRD §5.3): items on audio-kind tracks.
+	// Carries trackId so preview can play each audio track through its OWN
+	// <audio> element in parallel with the video (multi-track sound). Audio
+	// assets have no proxy, so preview reads originalPath.
+	const audioSegments = computed(() => {
+		if (!doc.value) return []
+		const audioTrackIds = new Set(
+			doc.value.tracks.filter((t) => t.kind === 'audio' && !t.hidden).map((t) => t.id)
+		)
+		const trackMuted = new Map(doc.value.tracks.map((t) => [t.id, t.muted]))
+		const assetById = new Map(doc.value.media.map((a) => [a.id, a]))
+
+		return doc.value.timeline
+			.filter((item) => audioTrackIds.has(item.trackId))
+			.sort((a, b) => a.timelineStart - b.timelineStart)
+			.flatMap((item) => {
+				const asset = assetById.get(item.sourceAssetId)
+				const src = asset?.originalPath
+				if (!src) return []
+				return [{
+					itemId: item.id,
+					trackId: item.trackId,
+					tStart: item.timelineStart,
+					tEnd: itemEnd(item),
+					src: `media://${src}`,
+					sourceIn: item.in,
+					speed: item.speed || 1,
+					muted: !!item.muted || !!trackMuted.get(item.trackId),
+					gain: item.gain ?? 1
+				}]
+			})
+	})
+
+	const pointerIndex = computed(() => {
+		const id = doc.value?.historyRef?.currentStepId || ''
+		if (id === '') return -1
+		return historySteps.value.findIndex((s) => s.id === id)
+	})
+
+	const canUndo = computed(() => pointerIndex.value >= 0)
+	const canRedo = computed(() => pointerIndex.value < historySteps.value.length - 1)
+
+	// ===== Persona computeds (M3) =====
+	// Resolution: project-local customPersonas -> global library (incl. builtins) -> default
+	const findPersona = (id: string | undefined | null): EditorPersona | null => {
+		if (!id) return null
+		return (
+			doc.value?.customPersonas?.find((p) => p.id === id) ||
+			personas.value.find((p) => p.id === id) ||
+			null
+		)
+	}
+
+	const activePersona = computed<EditorPersona | null>(() =>
+		findPersona(doc.value?.activePersonaId) ||
+		personas.value.find((p) => p.id === DEFAULT_PERSONA_ID) ||
+		personas.value[0] ||
+		null
+	)
+
+	const personasByMode = computed(() => ({
+		longform: personas.value.filter((p) => p.builtin && p.mode === 'longform'),
+		summarize: personas.value.filter((p) => p.builtin && p.mode === 'summarize'),
+		custom: [
+			...personas.value.filter((p) => !p.builtin),
+			...(doc.value?.customPersonas || [])
+		]
+	}))
+
+	// ===== Proposal computeds (M3) =====
+	const promptRunning = computed(() => activeTurnId.value !== null)
+
+	/** Live preview of what scope the NEXT prompt would use (drives the chip). */
+	const scopePreview = computed(() => {
+		if (!doc.value) return null
+		return computeScope({
+			timeline: doc.value.timeline,
+			markers: doc.value.markers || [],
+			selectedItemIds: selectedItemIds.value,
+			playheadSec: playheadSec.value,
+			mediaIds: doc.value.media.map((a) => a.id),
+			widen: scopeWiden.value === 'auto' ? undefined : scopeWiden.value
+		})
+	})
+
+	// ===== Revision computeds =====
+	const currentRevision = computed<EditorRevision | null>(() =>
+		revisions.value.find((r) => r.id === doc.value?.currentRevisionId) || null
+	)
+
+	/** Working state differs from the current revision's snapshot. */
+	const revisionDirty = computed(() => {
+		const rev = currentRevision.value
+		if (!rev || !doc.value) return false
+		return diffTimelines(
+			{ tracks: rev.snapshot.tracks, timeline: rev.snapshot.timeline },
+			{ tracks: doc.value.tracks, timeline: doc.value.timeline }
+		) !== null
+	})
+
+	/** Children grouped by parentId (null key = root), createdAt-sorted. */
+	const revisionChildren = computed<Map<string | null, EditorRevision[]>>(() => {
+		const map = new Map<string | null, EditorRevision[]>()
+		for (const rev of revisions.value) {
+			const list = map.get(rev.parentId) || []
+			list.push(rev)
+			map.set(rev.parentId, list)
+		}
+		for (const list of map.values()) list.sort((a, b) => a.createdAt - b.createdAt)
+		return map
+	})
+
+	// ===== Export computeds (M4) =====
+	const isRendering = computed(() =>
+		renderState.value?.phase === 'rendering' || renderState.value?.phase === 'stitching'
+	)
+
+	// The AI has nothing to work with until at least one asset finished
+	// preprocessing (pieces/transcript exist) — the chat gates on this.
+	const hasReadyMedia = computed(() =>
+		assets.value.some((a) => a.preprocessState === 'completed' && (a.clips?.length ?? 0) > 0)
+	)
+	const mediaProcessing = computed(() =>
+		assets.value.some((a) => a.preprocessState === 'running' || a.preprocessState === 'pending')
+	)
+
+	const canExport = computed(() => {
+		if (!doc.value || isRendering.value) return false
+		const videoTrack = sortedTracks.value.find((t) => t.kind === 'video')
+		if (!videoTrack || videoTrack.hidden) return false
+		return doc.value.timeline.some((i) => i.trackId === videoTrack.id)
+	})
+
+	const exportNotice = computed(() => {
+		if (!doc.value) return null
+		const hasOverlayItems = doc.value.timeline.some((item) => {
+			const track = doc.value!.tracks.find((t) => t.id === item.trackId)
+			return track && (track.kind === 'overlay' || track.kind === 'text')
+		})
+		return hasOverlayItems ? "Overlay/text tracks won't appear in this export." : null
+	})
+
+	// ===== Persistence =====
+	const markDirty = () => {
+		dirty.value = true
+		scheduleAutosave()
+	}
+
+	const scheduleAutosave = () => {
+		if (autosaveTimer) clearTimeout(autosaveTimer)
+		autosaveTimer = setTimeout(() => persistDoc(), 800)
+	}
+
+	const persistDoc = async () => {
+		if (!threadId.value || !doc.value || !dirty.value) return
+		saveInFlight.value = true
+		try {
+			const clipSelections: Record<string, boolean> = {}
+			for (const asset of doc.value.media) {
+				for (const clip of asset.clips) {
+					clipSelections[clip.id] = clip.selected
+				}
+			}
+			const patch = JSON.parse(JSON.stringify({
+				tracks: doc.value.tracks,
+				timeline: doc.value.timeline,
+				timelineMeta: doc.value.timelineMeta,
+				selection: doc.value.selection,
+				activePersonaId: doc.value.activePersonaId,
+				customPersonas: doc.value.customPersonas,
+				clipSelections,
+				// Undo pointer rides with the doc: state + pointer land atomically
+				historyRef: doc.value.historyRef,
+				markers: doc.value.markers,
+				currentRevisionId: doc.value.currentRevisionId
+			}))
+			await api.saveEditorDoc({ threadId: threadId.value, patch })
+			dirty.value = false
+		} catch (error) {
+			console.error('[editorStore] Failed to persist editor doc:', error)
+		} finally {
+			saveInFlight.value = false
+		}
+	}
+
+	// ===== Loading =====
+	const loadProject = async (id: string): Promise<boolean> => {
+		loading.value = true
+		try {
+			const loaded: Thread | null = await api.getThread(id)
+			if (!loaded || loaded.type !== 'editor' || !loaded.editor) {
+				return false
+			}
+			threadId.value = id
+			thread.value = loaded
+			doc.value = JSON.parse(JSON.stringify(loaded.editor))
+			dirty.value = false
+			selectedItemIds.value = doc.value?.selection?.itemIds || []
+			playheadSec.value = 0
+			isPlaying.value = false
+
+			// Heal any pre-existing same-track overlaps (e.g. from AI accepts
+			// made before overlap repair existed) — persists via autosave.
+			if (doc.value && repairOverlaps({ tracks: doc.value.tracks, timeline: doc.value.timeline })) {
+				console.warn('[editorStore] Repaired overlapping timeline items on load')
+				markDirty()
+			}
+
+			backgroundTasks.value = (await api.getBackgroundTasks(id)) || {}
+
+			// ---- Personas (global library incl. builtins) ----
+			try {
+				personas.value = (await api.getPersonas()) || []
+			} catch (error) {
+				console.error('[editorStore] Failed to load personas:', error)
+			}
+
+			// ---- Revisions sidecar + pointer reconciliation ----
+			// Invariant: losing/corrupting the sidecar NEVER mutates the working doc.
+			lastResult.value = null
+			try {
+				revisions.value = (await api.getEditorRevisions(id))?.revisions || []
+			} catch (error) {
+				console.error('[editorStore] Failed to load revisions:', error)
+				revisions.value = []
+			}
+			if (doc.value?.currentRevisionId &&
+				!revisions.value.some((r) => r.id === doc.value!.currentRevisionId)) {
+				// Sidecar lost or pointer dangling — clear and lazily re-bootstrap
+				delete doc.value.currentRevisionId
+				markDirty()
+			}
+
+			// ---- History rehydration + pointer recovery (crash windows) ----
+			try {
+				const hist = await api.getEditorHistory(id)
+				historySteps.value = hist?.steps || []
+				const docPointer = doc.value!.historyRef?.currentStepId || ''
+				const inSteps = (p: string) => p === '' || historySteps.value.some((s) => s.id === p)
+				if (!inSteps(docPointer)) {
+					// Doc references a step missing from the sidecar (crash between
+					// autosave and sidecar push): fall back to the sidecar pointer,
+					// else reset history entirely. The doc itself is never touched.
+					const sidecarPointer = hist?.currentStepId || ''
+					if (inSteps(sidecarPointer)) {
+						doc.value!.historyRef = { currentStepId: sidecarPointer, stepCount: historySteps.value.length }
+					} else {
+						historySteps.value = []
+						doc.value!.historyRef = { currentStepId: '', stepCount: 0 }
+					}
+					markDirty()
+				}
+			} catch (error) {
+				console.error('[editorStore] Failed to load history:', error)
+				historySteps.value = []
+			}
+
+			// Detect assets interrupted by an app quit mid-preprocess: persisted as
+			// 'running' but with no live task process. Any incoming task update for
+			// the asset clears the flag.
+			interruptedAssets.value = new Set(
+				(doc.value?.media || [])
+					.filter((a) => a.preprocessState === 'running')
+					.map((a) => a.id)
+			)
+
+			// Fire-and-forget: the scenedetect/yt-dlp binary checks spawn processes
+			// and can take seconds — never block first paint on them.
+			api.checkSystemRequirements()
+				.then((reqs: any) => {
+					deps.value = {
+						ffmpeg: reqs?.ffmpegAvailable !== false,
+						scenedetect: reqs?.scenedetectAvailable !== false,
+						ytDlp: reqs?.ytDlpAvailable !== false
+					}
+				})
+				.catch(() => { /* non-blocking */ })
+
+			if (!selectedAssetId.value && assets.value.length > 0) {
+				selectedAssetId.value = assets.value[0].id
+			}
+			return true
+		} finally {
+			loading.value = false
+		}
+	}
+
+	// ===== Media actions (M1) =====
+	const upsertAsset = (incoming: MediaAsset) => {
+		if (!doc.value) return
+		const index = doc.value.media.findIndex((a) => a.id === incoming.id)
+		if (index === -1) {
+			doc.value.media.push(incoming)
+		} else {
+			doc.value.media[index] = mergeMainOwnedAsset(doc.value.media[index], incoming)
+		}
+	}
+
+	const addLocalMedia = async () => {
+		if (!threadId.value) return
+		const result = await api.selectVideo()
+		if (!result?.path) return
+		const asset: MediaAsset | null = await api.addMediaAsset({
+			threadId: threadId.value,
+			filePath: result.path,
+			name: result.name
+		})
+		if (asset) {
+			upsertAsset(asset)
+			selectedAssetId.value = asset.id
+		}
+	}
+
+	const importUrl = async (url: string, resolution?: string) => {
+		if (!threadId.value) return
+		try {
+			const asset: MediaAsset | null = await api.importMediaUrl({
+				threadId: threadId.value,
+				url,
+				resolution
+			})
+			if (asset) {
+				delete urlImports.value[asset.id]
+				upsertAsset(asset)
+				selectedAssetId.value = asset.id
+			}
+			return asset
+		} catch (error) {
+			console.error('[editorStore] URL import failed:', error)
+			throw error
+		}
+	}
+
+	const removeAsset = async (assetId: string) => {
+		if (!threadId.value || !doc.value) return
+		const confirmed = await api.showConfirmation({
+			title: 'Remove media',
+			message: 'Remove this media and all its clips from the project?',
+			detail: 'The imported copy and generated thumbnails will be deleted. The original file on disk is not affected.',
+			buttons: ['Cancel', 'Remove']
+		})
+		if (!confirmed || confirmed.response !== 1) return
+		const success = await api.removeMediaAsset({ threadId: threadId.value, assetId })
+		if (success) {
+			doc.value.media = doc.value.media.filter((a) => a.id !== assetId)
+			if (selectedAssetId.value === assetId) selectedAssetId.value = doc.value.media[0]?.id || null
+			if (selectedClip.value?.sourceAssetId === assetId) selectedClipId.value = null
+			if (silenceScan.value?.assetId === assetId) silenceScan.value = null
+		}
+	}
+
+	const retryAsset = async (assetId: string, steps?: string[]) => {
+		if (!threadId.value) return
+		interruptedAssets.value.delete(assetId)
+		await api.preprocessMedia({ threadId: threadId.value, assetId, steps })
+	}
+
+	const describeAsset = async (assetId: string) => {
+		if (!threadId.value) return
+		await api.preprocessMedia({ threadId: threadId.value, assetId, steps: ['descriptions'] })
+	}
+
+	const transcribeAsset = async (assetId: string) => {
+		if (!threadId.value) return
+		await api.preprocessMedia({ threadId: threadId.value, assetId, steps: ['audio', 'transcript'] })
+	}
+
+	/** Remove derived Gemini data (transcript / scene descriptions) from an asset. */
+	const clearAssetData = async (assetId: string, kind: 'transcript' | 'descriptions') => {
+		if (!threadId.value) return
+		const label = kind === 'transcript' ? 'transcript' : 'scene descriptions'
+		const confirmed = await api.showConfirmation({
+			title: `Remove ${label}?`,
+			message: `Delete the ${label} for this media?`,
+			detail: `The ${label} data is removed from every piece. Regenerating it later runs Gemini again and costs tokens.`,
+			buttons: ['Cancel', 'Remove']
+		})
+		if (!confirmed || confirmed.response !== 1) return
+		const updated = await api.clearAssetData({ threadId: threadId.value, assetId, kind })
+		if (updated && doc.value) {
+			const index = doc.value.media.findIndex((a) => a.id === updated.id)
+			if (index !== -1) doc.value.media[index] = { ...doc.value.media[index], clips: updated.clips, preprocessing: updated.preprocessing }
+		}
+	}
+
+	/** Rename the project (title is a main-owned Thread field). */
+	const renameProject = async (title: string) => {
+		if (!threadId.value) return
+		const clean = title.trim().slice(0, 120)
+		if (!clean) return
+		if (thread.value) thread.value.title = clean // optimistic; thread-updated echoes it
+		await api.renameEditorProject({ threadId: threadId.value, title: clean })
+	}
+
+	// ===== Scene-piece corrections (§5.2) =====
+
+	/**
+	 * Lazily generate dense filmstrips (§5.5): fired when filmstrip view is
+	 * active, for completed assets that are used on the timeline and don't
+	 * have one yet. One batched ffmpeg pass per asset, cached on the asset.
+	 */
+	const filmstripRequested = new Set<string>()
+	const ensureFilmstrips = () => {
+		if (!threadId.value || !doc.value || timelineView.value !== 'filmstrip') return
+		const usedAssetIds = new Set(doc.value.timeline.map((i) => i.sourceAssetId))
+		for (const asset of doc.value.media) {
+			if (!usedAssetIds.has(asset.id)) continue
+			if (asset.preprocessState !== 'completed') continue
+			if (asset.filmstrip?.length || filmstripRequested.has(asset.id)) continue
+			filmstripRequested.add(asset.id)
+			api.preprocessMedia({ threadId: threadId.value, assetId: asset.id, steps: ['filmstrip'] })
+		}
+	}
+	watch([timelineView, () => doc.value?.timeline.length], () => ensureFilmstrips())
+
+	/** Re-run scene detection with a custom threshold (lower = more pieces). */
+	const redetectScenes = async (assetId: string, threshold: number) => {
+		if (!threadId.value) return
+		await api.preprocessMedia({
+			threadId: threadId.value,
+			assetId,
+			steps: ['scenes', 'thumbnails'],
+			threshold
+		})
+	}
+
+	/** Replace one asset's clips from a main-process response. */
+	const patchAssetClips = (updated: MediaAsset | null) => {
+		if (!updated || !doc.value) return
+		const index = doc.value.media.findIndex((a) => a.id === updated.id)
+		if (index !== -1) doc.value.media[index] = { ...doc.value.media[index], clips: updated.clips }
+	}
+
+	/** Merge the selected (adjacent) pieces of an asset. Returns an error message or null. */
+	const mergeSelectedClips = async (assetId: string): Promise<string | null> => {
+		if (!threadId.value || !doc.value) return null
+		const asset = doc.value.media.find((a) => a.id === assetId)
+		const clipIds = (asset?.clips || []).filter((c) => c.selected).map((c) => c.id)
+		if (clipIds.length < 2) return 'Select at least two pieces to merge.'
+		try {
+			patchAssetClips(await api.mergeClips({ threadId: threadId.value, assetId, clipIds }))
+			return null
+		} catch (error: any) {
+			return error?.message?.split('Error: ').pop() || 'Merge failed.'
+		}
+	}
+
+	/** Split each selected piece at its midpoint. Returns an error message or null. */
+	const splitSelectedClips = async (assetId: string): Promise<string | null> => {
+		if (!threadId.value || !doc.value) return null
+		const asset = doc.value.media.find((a) => a.id === assetId)
+		const clipIds = (asset?.clips || []).filter((c) => c.selected).map((c) => c.id)
+		if (!clipIds.length) return 'Select a piece to split.'
+		try {
+			let updated: MediaAsset | null = null
+			for (const clipId of clipIds) {
+				updated = await api.splitClip({ threadId: threadId.value, assetId, clipId })
+			}
+			patchAssetClips(updated)
+			return null
+		} catch (error: any) {
+			return error?.message?.split('Error: ').pop() || 'Split failed.'
+		}
+	}
+
+	// ===== Selection =====
+	const selectAsset = (assetId: string | null) => {
+		selectedAssetId.value = assetId
+		selectedClipId.value = null
+	}
+
+	const selectClip = (clipId: string | null) => {
+		selectedClipId.value = clipId
+	}
+
+	const toggleClipSelected = (clipId: string) => {
+		if (!doc.value) return
+		for (const asset of doc.value.media) {
+			const clip = asset.clips.find((c) => c.id === clipId)
+			if (clip) {
+				clip.selected = !clip.selected
+				markDirty()
+				return
+			}
+		}
+	}
+
+	// ===== Timeline item selection (M2) =====
+	const syncSelectionIntoDoc = () => {
+		if (!doc.value) return
+		doc.value.selection = { ...(doc.value.selection || {}), itemIds: [...selectedItemIds.value] }
+		markDirty()
+	}
+
+	const selectItems = (ids: string[]) => {
+		selectedItemIds.value = [...ids]
+		syncSelectionIntoDoc()
+	}
+
+	const toggleItemSelected = (id: string) => {
+		selectedItemIds.value = selectedItemIds.value.includes(id)
+			? selectedItemIds.value.filter((x) => x !== id)
+			: [...selectedItemIds.value, id]
+		syncSelectionIntoDoc()
+	}
+
+	const clearItemSelection = () => selectItems([])
+
+	// Drop selection entries for items that no longer exist (after undo/delete)
+	const pruneSelection = () => {
+		const existing = new Set((doc.value?.timeline || []).map((i) => i.id))
+		const pruned = selectedItemIds.value.filter((id) => existing.has(id))
+		if (pruned.length !== selectedItemIds.value.length) {
+			selectedItemIds.value = pruned
+			syncSelectionIntoDoc()
+		}
+	}
+
+	// ===== Playback control =====
+	const seekTo = (t: number) => {
+		const clamped = Math.min(Math.max(0, t), contentEnd.value + timelineTail.value)
+		playheadSec.value = clamped
+		seekRequest.value = { n: seekRequest.value.n + 1, time: clamped }
+	}
+
+	// ===== History engine (M2) =====
+	const currentState = (): TimelineState => ({
+		tracks: doc.value!.tracks,
+		timeline: doc.value!.timeline
+	})
+
+	const snapshotState = (): TimelineState =>
+		JSON.parse(JSON.stringify(currentState()))
+
+	const refreshMetaDuration = () => {
+		if (!doc.value) return
+		doc.value.timelineMeta = { ...doc.value.timelineMeta, duration: contentEnd.value }
+	}
+
+	/**
+	 * Commits ONE history step. Either diffs `before` against the current doc
+	 * (manual gestures) or takes a prebuilt forward/inverse pair (M3 AI accept).
+	 * Returns false when nothing changed.
+	 */
+	const commitStep = (
+		options: {
+			before?: TimelineState
+			prebuilt?: { forward: TimelineDiff; inverse: TimelineDiff }
+			label?: string
+			origin?: 'manual' | 'ai'
+			turnId?: string
+		}
+	): boolean => {
+		if (!doc.value || !threadId.value) return false
+
+		let forward: TimelineDiff, inverse: TimelineDiff
+		if (options.prebuilt) {
+			({ forward, inverse } = options.prebuilt)
+		} else if (options.before) {
+			const diffed = diffTimelines(options.before, currentState())
+			if (!diffed) return false
+			;({ forward, inverse } = diffed)
+		} else {
+			return false
+		}
+
+		const step: EditorHistoryStep = {
+			id: (crypto as any).randomUUID ? crypto.randomUUID() : `step-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+			seq: 0, // assigned by main (getNextVersion); mirrored back below
+			origin: options.origin || 'manual',
+			label: options.label,
+			forward,
+			inverse,
+			turnId: options.turnId,
+			createdAt: Date.now()
+		}
+
+		// Truncate any redo branch beyond the pointer, then append
+		const idx = pointerIndex.value
+		historySteps.value = [...historySteps.value.slice(0, idx + 1), step]
+		// Mirror the main-side ring cap (50)
+		if (historySteps.value.length > 50) {
+			historySteps.value = historySteps.value.slice(historySteps.value.length - 50)
+		}
+
+		doc.value.historyRef = { currentStepId: step.id, stepCount: historySteps.value.length }
+		refreshMetaDuration()
+		pruneSelection()
+		markDirty()
+
+		// Persist to the sidecar fire-and-forget; keyframe every 10th push
+		pushCounter++
+		const keyframe: TimelineSnapshot | undefined = pushCounter % 10 === 0
+			? { stepId: step.id, ...snapshotState(), timelineMeta: { ...doc.value.timelineMeta } }
+			: undefined
+		api.pushEditorStep({
+			threadId: threadId.value,
+			step: JSON.parse(JSON.stringify(step)),
+			keyframe: keyframe ? JSON.parse(JSON.stringify(keyframe)) : undefined
+		}).then((res: { seq: number } | null) => {
+			if (res?.seq) step.seq = res.seq
+		}).catch((error: unknown) => {
+			console.error('[editorStore] pushEditorStep failed:', error)
+		})
+
+		return true
+	}
+
+	const applyDiffToDoc = (diff: TimelineDiff): boolean => {
+		if (!doc.value) return false
+		// applyTimelineDiff reassigns arrays on its state argument, so work on a
+		// wrapper of shallow copies and write the results back to the doc.
+		const state: TimelineState = {
+			tracks: [...doc.value.tracks],
+			timeline: [...doc.value.timeline]
+		}
+		const result = applyTimelineDiff(state, diff, doc.value.media)
+		if (result.errors.length) {
+			console.warn('[editorStore] applyTimelineDiff reported:', result.errors)
+		}
+		doc.value.tracks = state.tracks
+		doc.value.timeline = state.timeline
+		return result.ok || result.errors.length < (diff.updateItems?.length || 0) + (diff.addItems?.length || 0) + 1
+	}
+
+	const movePointer = (stepId: string) => {
+		if (!doc.value || !threadId.value) return
+		doc.value.historyRef = { currentStepId: stepId, stepCount: historySteps.value.length }
+		refreshMetaDuration()
+		pruneSelection()
+		markDirty()
+		api.setEditorHistoryPointer({ threadId: threadId.value, currentStepId: stepId })
+			.catch((error: unknown) => console.error('[editorStore] setEditorHistoryPointer failed:', error))
+	}
+
+	const undo = () => {
+		const idx = pointerIndex.value
+		if (idx < 0) return
+		const step = historySteps.value[idx]
+		applyDiffToDoc(step.inverse)
+		movePointer(idx > 0 ? historySteps.value[idx - 1].id : '')
+	}
+
+	const redo = () => {
+		const idx = pointerIndex.value
+		if (idx >= historySteps.value.length - 1) return
+		const step = historySteps.value[idx + 1]
+		applyDiffToDoc(step.forward)
+		movePointer(step.id)
+	}
+
+	// ===== Timeline actions (each commits ONE history step) =====
+
+	const firstVideoTrackId = computed(() =>
+		sortedTracks.value.find((t) => t.kind === 'video' && !t.locked && !t.hidden)?.id || null
+	)
+
+	const firstAudioTrackId = computed(() =>
+		sortedTracks.value.find((t) => t.kind === 'audio' && !t.locked && !t.hidden)?.id || null
+	)
+
+	const findClip = (clipId: string): Clip | null => {
+		for (const asset of doc.value?.media || []) {
+			const clip = asset.clips.find((c) => c.id === clipId)
+			if (clip) return clip
+		}
+		return null
+	}
+
+	/** Nudge a candidate start right until [start, start+dur) is overlap-free on the track. */
+	const resolveFreePosition = (trackId: string, start: number, duration: number, ignoreId?: string): number => {
+		const items = (itemsByTrack.value[trackId] || []).filter((i) => i.id !== ignoreId)
+		let candidate = Math.max(0, start)
+		for (let guard = 0; guard < items.length + 1; guard++) {
+			const collision = items.find(
+				(i) => candidate < itemEnd(i) && candidate + duration > i.timelineStart
+			)
+			if (!collision) break
+			candidate = itemEnd(collision)
+		}
+		return candidate
+	}
+
+	const addItemFromClip = (clipId: string, trackId?: string | null, atSec?: number): TimelineItem | null => {
+		if (!doc.value) return null
+		const clip = findClip(clipId)
+		if (!clip) return null
+		const asset = doc.value.media.find((a) => a.id === clip.sourceAssetId)
+		// Default the target lane by the clip's kind (audio piece → audio lane).
+		const targetTrackId = trackId
+			|| (asset?.kind === 'audio' ? firstAudioTrackId.value : firstVideoTrackId.value)
+		if (!targetTrackId) return null
+		const track = doc.value.tracks.find((t) => t.id === targetTrackId)
+		if (!track || track.locked || track.hidden) return null
+		if (track.kind !== 'video' && track.kind !== (asset?.kind || 'video')) return null
+
+		const before = snapshotState()
+		const start = resolveFreePosition(targetTrackId, atSec ?? playheadSec.value, clip.duration)
+		const item = clipToItem(clip, targetTrackId, start)
+		doc.value.timeline.push(item)
+		commitStep({ before, label: `Add ${item.label || 'clip'}` })
+		selectItems([item.id])
+		return item
+	}
+
+	/**
+	 * Drop a WHOLE asset onto the timeline as a single full-span item. Defaults
+	 * the target track by kind (audio→A-lane, video→V-lane); kind must match
+	 * (audio assets only on audio tracks, video only on video tracks).
+	 */
+	const addItemFromAsset = (assetId: string, trackId?: string | null, atSec?: number): TimelineItem | null => {
+		if (!doc.value) return null
+		const asset = doc.value.media.find((a) => a.id === assetId)
+		if (!asset) return null
+		const targetTrackId = trackId || (asset.kind === 'audio' ? firstAudioTrackId.value : firstVideoTrackId.value)
+		if (!targetTrackId) return null
+		const track = doc.value.tracks.find((t) => t.id === targetTrackId)
+		if (!track || track.locked || track.hidden) return null
+		const compatible = asset.kind === 'audio' ? track.kind === 'audio' : track.kind === 'video'
+		if (!compatible) return null
+		const duration = asset.metadata?.duration || 0
+		if (duration <= 0) return null
+
+		const before = snapshotState()
+		const start = resolveFreePosition(targetTrackId, atSec ?? playheadSec.value, duration)
+		const item = itemFromAsset(asset, targetTrackId, start)
+		doc.value.timeline.push(item)
+		commitStep({ before, label: `Add ${asset.name}` })
+		selectItems([item.id])
+		return item
+	}
+
+	const splitAtPlayhead = () => {
+		if (!doc.value) return
+		const t = playheadSec.value
+		const candidates = (selectedItems.value.length ? selectedItems.value : doc.value.timeline)
+			.filter((i) => t > i.timelineStart + 0.01 && t < itemEnd(i) - 0.01)
+		if (!candidates.length) return
+
+		const before = snapshotState()
+		const newIds: string[] = []
+		for (const item of candidates) {
+			const sourceSplit = item.in + (t - item.timelineStart) * (item.speed || 1)
+			const right: TimelineItem = {
+				...JSON.parse(JSON.stringify(item)),
+				id: (crypto as any).randomUUID ? crypto.randomUUID() : `ti-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				timelineStart: t,
+				in: sourceSplit,
+				masterSegmentIndex: undefined, // sub-range no longer maps to one master scene
+				duration: (item.out - sourceSplit) / (item.speed || 1)
+			}
+			item.out = sourceSplit
+			item.duration = (item.out - item.in) / (item.speed || 1)
+			item.masterSegmentIndex = undefined
+			doc.value.timeline.push(right)
+			newIds.push(item.id, right.id)
+		}
+		commitStep({ before, label: 'Split' })
+		selectItems(newIds)
+	}
+
+	const deleteItems = (ids: string[], options: { ripple?: boolean } = {}) => {
+		if (!doc.value || !ids.length) return
+		const ripple = options.ripple !== false // magnetic default
+		const before = snapshotState()
+		const removed = doc.value.timeline.filter((i) => ids.includes(i.id))
+		doc.value.timeline = doc.value.timeline.filter((i) => !ids.includes(i.id))
+
+		if (ripple) {
+			// Close each track's gaps: shift remaining items left by the total
+			// duration of removed items that started before them (same track).
+			for (const item of doc.value.timeline) {
+				const shift = removed
+					.filter((r) => r.trackId === item.trackId && r.timelineStart < item.timelineStart)
+					.reduce((sum, r) => sum + itemDuration(r), 0)
+				if (shift > 0) item.timelineStart -= shift
+			}
+		}
+		commitStep({ before, label: ripple ? 'Ripple delete' : 'Delete' })
+	}
+
+	const rippleDownstream = (item: TimelineItem, delta: number) => {
+		if (!doc.value || Math.abs(delta) < 1e-9) return
+		for (const other of doc.value.timeline) {
+			if (other.id !== item.id && other.trackId === item.trackId && other.timelineStart > item.timelineStart) {
+				other.timelineStart = Math.max(0, other.timelineStart + delta)
+			}
+		}
+	}
+
+	const setItemSpeed = (id: string, speed: number) => {
+		const item = doc.value?.timeline.find((i) => i.id === id)
+		if (!item || !doc.value) return
+		const before = snapshotState()
+		const oldDuration = itemDuration(item)
+		item.speed = clampSpeed(speed)
+		item.duration = (item.out - item.in) / item.speed
+		rippleDownstream(item, item.duration - oldDuration)
+		commitStep({ before, label: `Speed ${item.speed.toFixed(2)}×` })
+	}
+
+	const setItemTargetDuration = (id: string, seconds: number) => {
+		const item = doc.value?.timeline.find((i) => i.id === id)
+		if (!item || seconds <= 0) return
+		setItemSpeed(id, (item.out - item.in) / seconds)
+	}
+
+	const setItemPreservePitch = (id: string, preservePitch: boolean) => {
+		const item = doc.value?.timeline.find((i) => i.id === id)
+		if (!item) return
+		const before = snapshotState()
+		item.preservePitch = preservePitch
+		commitStep({ before, label: 'Pitch mode' })
+	}
+
+	const toggleItemMuted = (id: string) => {
+		const item = doc.value?.timeline.find((i) => i.id === id)
+		if (!item) return
+		const before = snapshotState()
+		item.muted = !item.muted
+		commitStep({ before, label: item.muted ? 'Mute clip' : 'Unmute clip' })
+	}
+
+	const setItemGain = (id: string, gain: number) => {
+		const item = doc.value?.timeline.find((i) => i.id === id)
+		if (!item || !Number.isFinite(gain)) return
+		const before = snapshotState()
+		item.gain = Math.max(0, Math.min(2, gain))
+		commitStep({ before, label: `Gain ${item.gain.toFixed(2)}` })
+	}
+
+	const nudgeItems = (ids: string[], deltaSec: number) => {
+		if (!doc.value || !ids.length) return
+		const before = snapshotState()
+		const moving = doc.value.timeline.filter((i) => ids.includes(i.id))
+		for (const item of moving) {
+			item.timelineStart = Math.max(0, item.timelineStart + deltaSec)
+		}
+		// Overlap forbidden: revert wholesale on any collision
+		const collides = moving.some((item) =>
+			(itemsByTrack.value[item.trackId] || []).some(
+				(other) => other.id !== item.id && !ids.includes(other.id) &&
+					item.timelineStart < itemEnd(other) && itemEnd(item) > other.timelineStart
+			)
+		)
+		if (collides) {
+			doc.value.tracks = before.tracks
+			doc.value.timeline = before.timeline
+			return
+		}
+		commitStep({ before, label: 'Nudge' })
+	}
+
+	// Markers are renderer-owned and NOT undoable (outside TimelineDiff)
+	const addMarker = (time: number, label?: string) => {
+		if (!doc.value) return
+		const marker: EditorMarker = {
+			id: (crypto as any).randomUUID ? crypto.randomUUID() : `mk-${Date.now()}`,
+			time,
+			label
+		}
+		doc.value.markers = [...(doc.value.markers || []), marker].sort((a, b) => a.time - b.time)
+		markDirty()
+	}
+
+	const removeMarker = (id: string) => {
+		if (!doc.value?.markers) return
+		doc.value.markers = doc.value.markers.filter((m) => m.id !== id)
+		markDirty()
+	}
+
+	// ===== Silence / dead-air finder (§5.6) =====
+	// Read-only analysis; the caller reviews before applying. Scan state lives
+	// here (not in the Inspector) so results survive selection/mode changes.
+	const silenceScanning = ref(false)
+	const silenceScanPercent = ref<number | null>(null)
+	const silenceScan = ref<{ assetId: string; regions: { start: number; end: number }[] } | null>(null)
+	const silenceNoiseDb = ref(-30)
+	const silenceMinDurationSec = ref(0.5)
+
+	const findSilence = async (
+		assetId: string,
+		opts?: { noiseDb?: number; minDurationSec?: number }
+	): Promise<{ start: number; end: number }[]> => {
+		if (!threadId.value) return []
+		return await api.findSilence({ threadId: threadId.value, assetId, ...opts })
+	}
+
+	const scanSilence = async (assetId: string) => {
+		silenceScanning.value = true
+		silenceScanPercent.value = 0
+		try {
+			const regions = await findSilence(assetId, {
+				noiseDb: silenceNoiseDb.value,
+				minDurationSec: silenceMinDurationSec.value
+			})
+			silenceScan.value = { assetId, regions }
+		} finally {
+			silenceScanning.value = false
+			silenceScanPercent.value = null
+		}
+	}
+
+	const clearSilenceScan = () => {
+		silenceScan.value = null
+	}
+
+	/** Map a source-time position on `assetId` to the first timeline position it appears at, or null if unplaced. */
+	const sourceTimeToTimeline = (assetId: string, sourceT: number): number | null => {
+		if (!doc.value) return null
+		for (const item of doc.value.timeline) {
+			if (item.sourceAssetId === assetId && sourceT >= item.in && sourceT <= item.out) {
+				return item.timelineStart + (sourceT - item.in) / (item.speed || 1)
+			}
+		}
+		return null
+	}
+
+	/**
+	 * Apply reviewed silence regions (source seconds of `assetId`) as ripple-deletes:
+	 * carve each region out of every timeline item drawn from that asset and close
+	 * the removed on-timeline duration, preserving intentional (non-silence) gaps.
+	 * One undoable history step; never auto-invoked.
+	 */
+	const applySilenceRegions = (assetId: string, regions: { start: number; end: number }[]) => {
+		if (!doc.value || !regions.length) return
+
+		// Normalize + merge overlapping/adjacent regions.
+		const merged = [...regions]
+			.filter((r) => r.end > r.start)
+			.sort((a, b) => a.start - b.start)
+			.reduce<{ start: number; end: number }[]>((acc, r) => {
+				const last = acc[acc.length - 1]
+				if (last && r.start <= last.end) last.end = Math.max(last.end, r.end)
+				else acc.push({ ...r })
+				return acc
+			}, [])
+		if (!merged.length) return
+
+		// Keep-intervals of [in,out] after subtracting merged regions (clamped).
+		const keptIntervals = (inSec: number, outSec: number) => {
+			const kept: { start: number; end: number }[] = []
+			let cursor = inSec
+			for (const r of merged) {
+				if (r.end <= inSec) continue      // region entirely before this item
+				if (r.start >= outSec) break      // region entirely after — nothing more overlaps
+				const s = Math.max(inSec, r.start)
+				const e = Math.min(outSec, r.end)
+				if (s > cursor) kept.push({ start: cursor, end: s })
+				cursor = Math.max(cursor, e)
+			}
+			if (cursor < outSec) kept.push({ start: cursor, end: outSec })
+			return kept
+		}
+
+		const before = snapshotState()
+		const newTimeline: TimelineItem[] = []
+
+		const trackIds = Array.from(new Set(doc.value.timeline.map((i) => i.trackId)))
+		for (const trackId of trackIds) {
+			const items = doc.value.timeline
+				.filter((i) => i.trackId === trackId)
+				.sort((a, b) => a.timelineStart - b.timelineStart)
+
+			let removedSoFar = 0
+			for (const item of items) {
+				if (item.sourceAssetId !== assetId) {
+					// Untouched content: keep its own leading gap, close upstream removals.
+					newTimeline.push({ ...item, timelineStart: Math.max(0, item.timelineStart - removedSoFar) })
+					continue
+				}
+				const speed = item.speed || 1
+				const originalOnTimeline = itemDuration(item)
+				const kept = keptIntervals(item.in, item.out)
+				let pieceStart = Math.max(0, item.timelineStart - removedSoFar)
+				let keptOnTimeline = 0
+				for (const seg of kept) {
+					const dur = (seg.end - seg.start) / speed
+					newTimeline.push({
+						...JSON.parse(JSON.stringify(item)),
+						id: (crypto as any).randomUUID ? crypto.randomUUID() : `ti-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+						in: seg.start,
+						out: seg.end,
+						duration: dur,
+						timelineStart: pieceStart,
+						masterSegmentIndex: undefined // sub-range no longer maps to one master scene
+					})
+					pieceStart += dur
+					keptOnTimeline += dur
+				}
+				removedSoFar += originalOnTimeline - keptOnTimeline
+			}
+		}
+
+		doc.value.timeline = newTimeline
+		commitStep({ before, label: 'Remove silence' })
+		if (silenceScan.value?.assetId === assetId) silenceScan.value = null
+	}
+
+	const toggleTrackFlag = (trackId: string, flag: 'muted' | 'locked' | 'hidden') => {
+		const track = doc.value?.tracks.find((t) => t.id === trackId)
+		if (!track) return
+		const before = snapshotState()
+		track[flag] = !track[flag]
+		commitStep({ before, label: `Track ${flag}` })
+	}
+
+	const addOverlayTrack = () => {
+		if (!doc.value) return
+		const before = snapshotState()
+		const count = doc.value.tracks.filter((t) => t.kind === 'overlay').length
+		doc.value.tracks.push({
+			id: (crypto as any).randomUUID ? crypto.randomUUID() : `tr-${Date.now()}`,
+			kind: 'overlay',
+			name: `OV${count + 1}`,
+			order: Math.max(...doc.value.tracks.map((t) => t.order)) + 1,
+			muted: false,
+			locked: false,
+			hidden: false,
+			height: 48
+		})
+		commitStep({ before, label: 'Add overlay track' })
+	}
+
+	// ===== Persona actions (M3) =====
+	const setActivePersona = (id: string) => {
+		if (!doc.value) return
+		doc.value.activePersonaId = id
+		markDirty()
+	}
+
+	/** Create or update a persona in the GLOBAL library (main filters builtins). */
+	const savePersona = async (persona: EditorPersona) => {
+		const userPersonas = personas.value.filter((p) => !p.builtin && p.id !== persona.id)
+		const merged = await api.setPersonas(
+			JSON.parse(JSON.stringify([...userPersonas, { ...persona, builtin: false, featureSets: [] }]))
+		)
+		if (merged) personas.value = merged
+	}
+
+	const clonePersona = (sourceId: string): EditorPersona | null => {
+		const source = findPersona(sourceId) || personas.value.find((p) => p.id === sourceId)
+		if (!source) return null
+		return {
+			...JSON.parse(JSON.stringify(source)),
+			id: (crypto as any).randomUUID ? crypto.randomUUID() : `persona-${Date.now()}`,
+			name: `Copy of ${source.name}`,
+			builtin: false,
+			featureSets: []
+		}
+	}
+
+	const deletePersona = async (id: string) => {
+		const target = personas.value.find((p) => p.id === id)
+		if (!target || target.builtin) return // built-ins can't be deleted
+		const merged = await api.setPersonas(
+			JSON.parse(JSON.stringify(personas.value.filter((p) => !p.builtin && p.id !== id)))
+		)
+		if (merged) personas.value = merged
+		if (doc.value?.activePersonaId === id) {
+			setActivePersona(DEFAULT_PERSONA_ID)
+		}
+	}
+
+	// ===== Revision actions =====
+	const deepClone = <T>(v: T): T => JSON.parse(JSON.stringify(v))
+
+	const snapshotOfWorkingState = () => deepClone({
+		tracks: doc.value!.tracks,
+		timeline: doc.value!.timeline,
+		timelineMeta: doc.value!.timelineMeta,
+		markers: doc.value!.markers || []
+	})
+
+	/** Push to the sidecar and mirror the assigned seq back (awaited — cards need real V numbers). */
+	const pushRevisionInternal = async (rev: EditorRevision): Promise<EditorRevision> => {
+		revisions.value = [...revisions.value, rev]
+		try {
+			const res = await api.pushEditorRevision({ threadId: threadId.value, revision: deepClone(rev) })
+			if (res?.seq) rev.seq = res.seq
+		} catch (error) {
+			console.error('[editorStore] pushEditorRevision failed:', error)
+		}
+		return rev
+	}
+
+	/** Lazy root bootstrap: the parent chain is never empty; zero migration. */
+	const ensureRootRevision = async (): Promise<EditorRevision | null> => {
+		if (!doc.value || !threadId.value) return null
+		if (revisions.value.length === 0) {
+			const root: EditorRevision = {
+				id: (crypto as any).randomUUID ? crypto.randomUUID() : `rev-${Date.now()}`,
+				parentId: null,
+				seq: 0,
+				origin: 'init',
+				label: 'Original',
+				snapshot: snapshotOfWorkingState(),
+				createdAt: Date.now()
+			}
+			await pushRevisionInternal(root)
+			doc.value.currentRevisionId = root.id
+			markDirty()
+			return root
+		}
+		// Revisions exist but the pointer dangles (crash window): re-point at the
+		// newest WITHOUT touching the working doc.
+		if (!currentRevision.value) {
+			const newest = [...revisions.value].sort((a, b) => b.createdAt - a.createdAt)[0]
+			doc.value.currentRevisionId = newest.id
+			markDirty()
+		}
+		return currentRevision.value
+	}
+
+	const createRevision = async (options: {
+		origin: 'ai' | 'manual'
+		label?: string
+		turnId?: string
+		personaId?: string
+	}): Promise<EditorRevision | null> => {
+		if (!doc.value || !threadId.value) return null
+		await ensureRootRevision()
+		// Manual checkpoint with nothing changed = no-op (return the current node)
+		if (options.origin === 'manual' && !revisionDirty.value) return currentRevision.value
+		const rev: EditorRevision = {
+			id: (crypto as any).randomUUID ? crypto.randomUUID() : `rev-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+			parentId: doc.value.currentRevisionId || null,
+			seq: 0,
+			origin: options.origin,
+			label: options.label?.trim() || (options.origin === 'ai' ? 'AI edit' : 'Checkpoint'),
+			turnId: options.turnId,
+			personaId: options.personaId,
+			snapshot: snapshotOfWorkingState(),
+			createdAt: Date.now()
+		}
+		await pushRevisionInternal(rev)
+		doc.value.currentRevisionId = rev.id
+		markDirty()
+		return rev
+	}
+
+	/**
+	 * Switches the working state to a revision's snapshot.
+	 * Resets the fine-grained undo ring (its diffs were computed against
+	 * pre-switch states — redo onto the switched snapshot would corrupt it).
+	 */
+	const switchRevision = async (id: string, options: { force?: boolean } = {}): Promise<boolean> => {
+		if (!doc.value || !threadId.value) return false
+		if (id === doc.value.currentRevisionId) return true
+		const target = revisions.value.find((r) => r.id === id)
+		if (!target) return false
+		if (promptRunning.value) return false // blocked: completing turn would land on the wrong parent
+
+		if (!options.force && revisionDirty.value) {
+			const confirmed = await api.showConfirmation({
+				title: 'Unsaved changes',
+				message: 'Your timeline has changes not saved to a revision.',
+				detail: 'Save them as a revision before switching, or discard them?',
+				buttons: ['Cancel', 'Discard changes', 'Save & switch'],
+				defaultId: 2,
+				cancelId: 0
+			})
+			if (!confirmed || confirmed.response === 0) return false
+			if (confirmed.response === 2) {
+				await createRevision({ origin: 'manual', label: 'Manual save' })
+			}
+		}
+
+		// Apply the snapshot
+		const snap = deepClone(target.snapshot)
+		doc.value.tracks = snap.tracks
+		doc.value.timeline = snap.timeline
+		doc.value.timelineMeta = snap.timelineMeta
+		doc.value.markers = snap.markers || []
+		doc.value.currentRevisionId = id
+
+		// Ring reset (local + sidecar; pointer-only reset would rehydrate stale steps)
+		historySteps.value = []
+		doc.value.historyRef = { currentStepId: '', stepCount: 0 }
+		api.clearEditorHistory({ threadId: threadId.value })
+			.catch((error: unknown) => console.error('[editorStore] clearEditorHistory failed:', error))
+
+		// Hygiene
+		clearItemSelection()
+		refreshMetaDuration()
+		seekTo(Math.min(playheadSec.value, contentEnd.value))
+		lastResult.value = null
+		markDirty()
+		return true
+	}
+
+	const saveCheckpoint = async (label?: string): Promise<'saved' | 'clean' | null> => {
+		if (!doc.value) return null
+		await ensureRootRevision()
+		if (!revisionDirty.value) return 'clean'
+		const rev = await createRevision({ origin: 'manual', label: label || 'Checkpoint' })
+		return rev ? 'saved' : null
+	}
+
+	const deleteRevisionSubtree = async (id: string): Promise<boolean> => {
+		if (!doc.value || !threadId.value || promptRunning.value) return false
+		const target = revisions.value.find((r) => r.id === id)
+		if (!target || target.parentId === null) return false // root undeletable
+
+		// Collect the subtree (chat's removeMessageBranch pattern)
+		const ids = new Set<string>()
+		const collect = (revId: string) => {
+			ids.add(revId)
+			for (const child of revisionChildren.value.get(revId) || []) collect(child.id)
+		}
+		collect(id)
+
+		// If current is inside, land on the subtree root's parent first
+		if (ids.has(doc.value.currentRevisionId || '')) {
+			const ok = await switchRevision(target.parentId)
+			if (!ok) return false
+		}
+
+		const confirmed = await api.showConfirmation({
+			title: 'Delete revisions',
+			message: `Delete V${target.seq}${ids.size > 1 ? ` and ${ids.size - 1} descendant revision(s)` : ''}?`,
+			detail: 'The timeline states saved in them will be lost. The current timeline is not affected.',
+			buttons: ['Cancel', 'Delete']
+		})
+		if (!confirmed || confirmed.response !== 1) return false
+
+		await api.deleteEditorRevisions({ threadId: threadId.value, ids: [...ids] })
+		revisions.value = revisions.value.filter((r) => !ids.has(r.id))
+		return true
+	}
+
+	const dismissResult = () => {
+		lastResult.value = null
+	}
+
+	// ===== AI prompt actions (M3) =====
+	const runPrompt = async (prompt: string) => {
+		if (!threadId.value || !doc.value || promptRunning.value) return
+		promptError.value = null
+		lastAnswer.value = null
+		// Flush the debounced autosave so main's doc (the context source) is current
+		dirty.value = true
+		await persistDoc()
+		try {
+			const result = await api.runEditorPrompt({
+				threadId: threadId.value,
+				personaId: activePersona.value?.id || DEFAULT_PERSONA_ID,
+				prompt,
+				baseStepId: doc.value.historyRef.currentStepId,
+				selectedItemIds: JSON.parse(JSON.stringify(selectedItemIds.value)),
+				playheadSec: playheadSec.value,
+				widen: scopeWiden.value === 'auto' ? undefined : scopeWiden.value
+			})
+			if (result?.turnId) activeTurnId.value = result.turnId
+		} catch (error: any) {
+			promptError.value = error?.message || 'Failed to start the prompt'
+		}
+	}
+
+	const abortPrompt = async () => {
+		if (!threadId.value || !activeTurnId.value) return
+		await api.abortEditorPrompt({ threadId: threadId.value, turnId: activeTurnId.value })
+	}
+
+	/**
+	 * Validates a proposal diff against the CURRENT doc by dry-running it on a
+	 * copy; returns the applied copy + human-readable pruned-op notes.
+	 */
+	const dryRunProposal = (diff: TimelineDiff): { applied: TimelineState; pruned: string[] } => {
+		const applied: TimelineState = {
+			tracks: JSON.parse(JSON.stringify(doc.value!.tracks)),
+			timeline: JSON.parse(JSON.stringify(doc.value!.timeline))
+		}
+		const result = applyTimelineDiff(applied, diff, doc.value!.media)
+		// AI placements aren't gesture-clamped — push any same-track overlaps
+		// right so the applied state always satisfies the M2 no-overlap invariant.
+		repairOverlaps(applied)
+		return { applied, pruned: result.errors }
+	}
+
+	const dismissAnswer = () => {
+		lastAnswer.value = null
+	}
+
+	// ===== Export actions (M4) =====
+	const startExport = async (quality: 'original' | 'preview') => {
+		if (!threadId.value || !canExport.value) return
+		// Flush the debounced autosave — main renders from the persisted doc
+		dirty.value = true
+		await persistDoc()
+		renderState.value = { renderId: '', percent: 0, phase: 'rendering' }
+		try {
+			const result = await api.exportEditorTimeline({ threadId: threadId.value, quality })
+			if (result?.renderId && renderState.value) {
+				renderState.value = { ...renderState.value, renderId: result.renderId }
+			}
+		} catch (error: any) {
+			// Pre-flight rejection (missing files, empty timeline, …)
+			renderState.value = {
+				renderId: '',
+				percent: 0,
+				phase: 'error',
+				error: error?.message || 'Export failed to start'
+			}
+		}
+	}
+
+	const abortExport = async () => {
+		if (!renderState.value?.renderId) return
+		await api.abortEditorRender({ renderId: renderState.value.renderId })
+	}
+
+	const clearRenderState = () => {
+		renderState.value = null
+	}
+
+	/**
+	 * Handles a completed/errored turn: the diff is APPLIED IMMEDIATELY and
+	 * lands as a new revision (branching from the current one). No accept/
+	 * reject — jumping back = switching to the parent revision.
+	 */
+	const onTurnUpdate = async (payload: {
+		threadId: string
+		turn: PromptTurn
+		addMarkers?: { time: number; label: string }[]
+		thinContext?: boolean
+		truncated?: boolean
+	}) => {
+		if (payload.threadId !== threadId.value || !doc.value) return
+		const turn = payload.turn
+
+		// Upsert into doc.turns (main-owned; echo also arrives via thread-updated)
+		const index = doc.value.turns.findIndex((t) => t.id === turn.id)
+		if (index === -1) doc.value.turns.push(turn)
+		else doc.value.turns[index] = turn
+
+		if (turn.id !== activeTurnId.value && turn.status === 'running') return
+
+		if (turn.status === 'completed') {
+			activeTurnId.value = null
+			if (turn.answer && !hasOps(turn.diff)) {
+				lastAnswer.value = { turnId: turn.id, text: turn.answer }
+				return
+			}
+			const markers = payload.addMarkers || []
+			if (!hasOps(turn.diff) && !markers.length) {
+				promptError.value = 'The AI proposed no changes. Try a more specific request.'
+				return
+			}
+
+			// Validate against the live doc (prune stale ops + repair overlaps)
+			const { applied, pruned } = dryRunProposal(turn.diff!)
+			const before = currentState()
+			const diffed = diffTimelines(before, applied)
+			if (!diffed && !markers.length) {
+				promptError.value = 'Nothing applicable — the timeline changed while the AI was working.'
+				return
+			}
+
+			await ensureRootRevision()
+			// Unsaved manual work is auto-checkpointed FIRST, so the AI revision's
+			// parent snapshot is exactly the state the diff applied to and nothing
+			// is ever stranded inside a child snapshot.
+			if (revisionDirty.value) {
+				await createRevision({ origin: 'manual', label: 'Auto checkpoint' })
+			}
+
+			const persona = findPersona(turn.personaId)
+			if (diffed) {
+				doc.value.tracks = applied.tracks
+				doc.value.timeline = applied.timeline
+				// Ring step preserved: Cmd+Z undoes the AI diff in place
+				commitStep({ prebuilt: diffed, origin: 'ai', turnId: turn.id, label: persona?.name || 'AI edit' })
+			}
+			for (const m of markers) addMarker(m.time, m.label)
+
+			const rev = await createRevision({
+				origin: 'ai',
+				turnId: turn.id,
+				personaId: turn.personaId,
+				label: persona?.name || 'AI edit'
+			})
+			if (rev && threadId.value) {
+				api.updateEditorTurn({
+					threadId: threadId.value,
+					turnId: turn.id,
+					patch: { resultStepId: doc.value.historyRef.currentStepId, revisionId: rev.id }
+				}).catch(() => { /* non-critical */ })
+
+				lastResult.value = {
+					turnId: turn.id,
+					revisionId: rev.id,
+					revisionSeq: rev.seq,
+					parentRevisionId: rev.parentId,
+					counts: {
+						added: diffed?.forward.addItems?.length || 0,
+						removed: diffed?.forward.removeItemIds?.length || 0,
+						updated: diffed?.forward.updateItems?.length || 0,
+						markers: markers.length
+					},
+					rationale: turn.rationale,
+					droppedOps: [...(turn.droppedOps || []), ...pruned],
+					scopeLabel: turn.scopeLabel,
+					thinContext: !!payload.thinContext,
+					truncated: !!payload.truncated
+				}
+			}
+		} else if (turn.status === 'error') {
+			activeTurnId.value = null
+			promptError.value = turn.error || 'Prompt failed'
+		}
+	}
+
+	const hasOps = (diff?: TimelineDiff): boolean =>
+		!!diff && !!(
+			diff.addItems?.length || diff.removeItemIds?.length ||
+			diff.updateItems?.length || diff.addTracks?.length || diff.removeTrackIds?.length
+		)
+
+	// ===== Ownership-split merge for thread-updated echoes =====
+	const mergeMainOwnedAsset = (local: MediaAsset, remote: MediaAsset): MediaAsset => {
+		// Take main-owned fields from remote; preserve renderer-owned clip.selected
+		// while an autosave is pending (remote may be a pre-save echo).
+		const preserveSelected = dirty.value || saveInFlight.value
+		const localSelected = new Map(local.clips.map((c) => [c.id, c.selected]))
+		return {
+			...remote,
+			clips: remote.clips.map((clip) => ({
+				...clip,
+				selected: preserveSelected && localSelected.has(clip.id)
+					? (localSelected.get(clip.id) as boolean)
+					: clip.selected
+			}))
+		}
+	}
+
+	const onThreadUpdatedMerge = (updated: Thread) => {
+		if (!threadId.value || updated.id !== threadId.value) return
+		thread.value = updated
+		if (!updated.editor || !doc.value) return
+
+		// Turns are main-owned — merge unconditionally (like media)
+		doc.value.turns = updated.editor.turns || doc.value.turns
+
+		const remoteMedia = updated.editor.media || []
+		const remoteIds = new Set(remoteMedia.map((a) => a.id))
+
+		// Merge main-owned media state
+		const merged: MediaAsset[] = remoteMedia.map((remote) => {
+			const local = doc.value!.media.find((a) => a.id === remote.id)
+			if (remote.preprocessState !== 'running') interruptedAssets.value.delete(remote.id)
+			return local ? mergeMainOwnedAsset(local, remote) : remote
+		})
+		// Keep local-only assets (mid-creation, not yet broadcast)
+		for (const local of doc.value.media) {
+			if (!remoteIds.has(local.id)) {
+				const stillImporting = urlImports.value[local.id] !== undefined
+				if (stillImporting) merged.push(local)
+			}
+		}
+		doc.value.media = merged
+
+		// Renderer-owned doc fields: only accept remote when no local edit is pending
+		if (!dirty.value && !saveInFlight.value) {
+			doc.value.tracks = updated.editor.tracks
+			doc.value.timeline = updated.editor.timeline
+			doc.value.timelineMeta = updated.editor.timelineMeta
+			doc.value.selection = updated.editor.selection
+			doc.value.activePersonaId = updated.editor.activePersonaId
+			doc.value.customPersonas = updated.editor.customPersonas
+			doc.value.historyRef = updated.editor.historyRef
+			doc.value.markers = updated.editor.markers
+			doc.value.currentRevisionId = updated.editor.currentRevisionId
+		}
+
+		if (selectedAssetId.value && !doc.value.media.some((a) => a.id === selectedAssetId.value)) {
+			selectedAssetId.value = doc.value.media[0]?.id || null
+		}
+	}
+
+	// ===== Singleton IPC listeners (registered once, like videoStore) =====
+	if (typeof window !== 'undefined' && api) {
+		api.onBackgroundTaskUpdate((data: { threadId: string; taskId: string; task: BackgroundTask }) => {
+			if (data.threadId !== threadId.value) return
+			backgroundTasks.value = { ...backgroundTasks.value, [data.taskId]: data.task }
+			const assetId = data.taskId.split(':')[0]
+			if (assetId) interruptedAssets.value.delete(assetId)
+		})
+
+		api.onThreadUpdated((updated: Thread) => {
+			try {
+				onThreadUpdatedMerge(updated)
+			} catch (error) {
+				console.error('[editorStore] thread-updated merge failed:', error)
+			}
+		})
+
+		if (api.onEditorImportProgress) {
+			api.onEditorImportProgress((data: { threadId: string; assetId: string; url?: string; percent: number }) => {
+				if (data.threadId !== threadId.value) return
+				urlImports.value = {
+					...urlImports.value,
+					[data.assetId]: { url: data.url || '', percent: data.percent }
+				}
+			})
+		}
+
+		if (api.onEditorSilenceProgress) {
+			api.onEditorSilenceProgress((data: { assetId: string; percent: number }) => {
+				if (silenceScanning.value) silenceScanPercent.value = data.percent
+			})
+		}
+
+		if (api.onEditorTurnUpdate) {
+			api.onEditorTurnUpdate((data: any) => {
+				onTurnUpdate(data).catch((error: unknown) => {
+					console.error('[editorStore] turn update failed:', error)
+				})
+			})
+		}
+
+		if (api.onEditorRenderProgress) {
+			api.onEditorRenderProgress((data: {
+				threadId: string; renderId: string; percent: number
+				phase: 'rendering' | 'stitching' | 'done' | 'error'
+				outputPath?: string; error?: string
+			}) => {
+				if (data.threadId !== threadId.value) return
+				// Ignore stale renders (a fresh export may have started)
+				if (renderState.value?.renderId && data.renderId !== renderState.value.renderId) return
+				renderState.value = {
+					renderId: data.renderId,
+					percent: data.percent,
+					phase: data.phase,
+					outputPath: data.outputPath,
+					error: data.error
+				}
+			})
+		}
+	}
+
+	return {
+		// state
+		threadId,
+		thread,
+		doc,
+		backgroundTasks,
+		selectedAssetId,
+		selectedClipId,
+		urlImports,
+		interruptedAssets,
+		dirty,
+		saveInFlight,
+		deps,
+		loading,
+		// timeline view state
+		playheadSec,
+		isPlaying,
+		pxPerSecond,
+		timelineView,
+		snapEnabled,
+		seekRequest,
+		selectedItemIds,
+		// computeds
+		assets,
+		isEmpty,
+		hasReadyMedia,
+		mediaProcessing,
+		selectedAsset,
+		selectedClip,
+		sortedTracks,
+		itemsByTrack,
+		contentEnd,
+		timelineTail,
+		markers,
+		selectedItems,
+		videoSegments,
+		audioSegments,
+		canUndo,
+		canRedo,
+		firstVideoTrackId,
+		firstAudioTrackId,
+		historySteps,
+		// helpers
+		assetTasks,
+		assetProgress,
+		// actions
+		loadProject,
+		addLocalMedia,
+		importUrl,
+		removeAsset,
+		retryAsset,
+		describeAsset,
+		transcribeAsset,
+		clearAssetData,
+		renameProject,
+		redetectScenes,
+		mergeSelectedClips,
+		splitSelectedClips,
+		selectAsset,
+		selectClip,
+		toggleClipSelected,
+		markDirty,
+		persistDoc,
+		// timeline actions
+		selectItems,
+		toggleItemSelected,
+		clearItemSelection,
+		seekTo,
+		commitStep,
+		snapshotState,
+		undo,
+		redo,
+		addItemFromClip,
+		addItemFromAsset,
+		splitAtPlayhead,
+		deleteItems,
+		setItemSpeed,
+		setItemTargetDuration,
+		setItemPreservePitch,
+		toggleItemMuted,
+		setItemGain,
+		nudgeItems,
+		addMarker,
+		removeMarker,
+		findSilence,
+		silenceScanning,
+		silenceScanPercent,
+		silenceScan,
+		silenceNoiseDb,
+		silenceMinDurationSec,
+		scanSilence,
+		clearSilenceScan,
+		sourceTimeToTimeline,
+		applySilenceRegions,
+		toggleTrackFlag,
+		addOverlayTrack,
+		// personas
+		personas,
+		activePersona,
+		personasByMode,
+		setActivePersona,
+		savePersona,
+		clonePersona,
+		deletePersona,
+		// AI prompt
+		activeTurnId,
+		lastAnswer,
+		promptError,
+		scopeWiden,
+		promptRunning,
+		scopePreview,
+		runPrompt,
+		abortPrompt,
+		dismissAnswer,
+		// revisions
+		revisions,
+		currentRevision,
+		revisionDirty,
+		revisionChildren,
+		lastResult,
+		ensureRootRevision,
+		createRevision,
+		switchRevision,
+		saveCheckpoint,
+		deleteRevisionSubtree,
+		dismissResult,
+		// export
+		renderState,
+		isRendering,
+		canExport,
+		exportNotice,
+		startExport,
+		abortExport,
+		clearRenderState
+	}
+})
diff --git a/src/shared/ai-scope.ts b/src/shared/ai-scope.ts
new file mode 100644
index 0000000..f18976a
--- /dev/null
+++ b/src/shared/ai-scope.ts
@@ -0,0 +1,132 @@
+import type { EditorMarker, TimelineItem } from './types'
+import { itemEnd } from './timeline'
+
+/**
+ * AI context scoping for the editor prompt (PRD §5.7 context windowing).
+ * Pure — no Node/Electron imports. Used by BOTH the renderer (live scope chip
+ * in the prompt bar) and main (buildPromptContext), so the label the user sees
+ * always matches what the model receives.
+ */
+
+export const SCOPE_ENGAGE_DURATION_SEC = 2400 // ~40 min: past this, chapter windowing engages
+export const SCOPE_ENGAGE_ITEM_COUNT = 400
+export const SELECTION_NEIGHBORHOOD = 2       // items each side, per track
+export const CHAPTER_FALLBACK_SPAN_SEC = 300  // ±5 min around playhead when no markers
+export const MAX_WINDOW_ITEMS = 150           // hard cap; nearest-playhead kept
+
+export type AiScopeKind = 'selection' | 'chapter' | 'full'
+
+export interface AiScope {
+	kind: AiScopeKind
+	label: string
+	itemIds: string[]           // in-scope item ids, timelineStart order
+	assetIds: string[]          // assets referenced by in-scope items (or all when timeline empty)
+}
+
+export interface ScopeInput {
+	timeline: TimelineItem[]
+	markers: EditorMarker[]
+	selectedItemIds: string[]
+	playheadSec: number
+	mediaIds: string[]
+	widen?: 'chapter' | 'full'
+}
+
+const byStart = (a: TimelineItem, b: TimelineItem) => a.timelineStart - b.timelineStart
+
+const assetsOf = (items: TimelineItem[], fallback: string[]): string[] => {
+	const ids = [...new Set(items.map((i) => i.sourceAssetId))]
+	return ids.length ? ids : fallback
+}
+
+export function computeScope(input: ScopeInput): AiScope {
+	const { timeline, markers, selectedItemIds, playheadSec, mediaIds, widen } = input
+	const sorted = [...timeline].sort(byStart)
+	const totalDuration = sorted.reduce((end, i) => Math.max(end, itemEnd(i)), 0)
+
+	// Empty timeline: full scope, all assets available (build-from-scratch)
+	if (sorted.length === 0) {
+		return { kind: 'full', label: 'Whole timeline · empty', itemIds: [], assetIds: mediaIds }
+	}
+
+	// 1. Explicit widen to full
+	if (widen === 'full') {
+		return fullScope(sorted, mediaIds)
+	}
+
+	// 2. Selection scope (+neighborhood per track)
+	if (selectedItemIds.length > 0 && widen !== 'chapter') {
+		const selected = sorted.filter((i) => selectedItemIds.includes(i.id))
+		if (selected.length > 0) {
+			const inScope = new Set<string>(selected.map((i) => i.id))
+			const byTrack = new Map<string, TimelineItem[]>()
+			for (const item of sorted) {
+				const list = byTrack.get(item.trackId) || []
+				list.push(item)
+				byTrack.set(item.trackId, list)
+			}
+			for (const item of selected) {
+				const lane = byTrack.get(item.trackId) || []
+				const idx = lane.findIndex((i) => i.id === item.id)
+				for (let d = 1; d <= SELECTION_NEIGHBORHOOD; d++) {
+					if (lane[idx - d]) inScope.add(lane[idx - d].id)
+					if (lane[idx + d]) inScope.add(lane[idx + d].id)
+				}
+			}
+			const items = sorted.filter((i) => inScope.has(i.id))
+			return {
+				kind: 'selection',
+				label: `Selection · ${selected.length} item${selected.length === 1 ? '' : 's'}`,
+				itemIds: items.map((i) => i.id),
+				assetIds: assetsOf(items, mediaIds)
+			}
+		}
+	}
+
+	// 3. Chapter window for long projects (or explicit widen: 'chapter')
+	const isLong = totalDuration > SCOPE_ENGAGE_DURATION_SEC || sorted.length > SCOPE_ENGAGE_ITEM_COUNT
+	if (isLong || widen === 'chapter') {
+		const sortedMarkers = [...markers].sort((a, b) => a.time - b.time)
+		let t0 = 0
+		let t1 = totalDuration
+		let chapterLabel = ''
+		if (sortedMarkers.length > 0) {
+			const prev = [...sortedMarkers].reverse().find((m) => m.time <= playheadSec)
+			const next = sortedMarkers.find((m) => m.time > playheadSec)
+			t0 = prev?.time ?? 0
+			t1 = next?.time ?? totalDuration
+			const chapterIndex = prev ? sortedMarkers.indexOf(prev) + 1 : 0
+			chapterLabel = prev?.label ? `Chapter ${chapterIndex} “${prev.label}”` : `Chapter ${chapterIndex + (prev ? 0 : 1)}`
+		} else {
+			t0 = Math.max(0, playheadSec - CHAPTER_FALLBACK_SPAN_SEC)
+			t1 = Math.min(totalDuration, playheadSec + CHAPTER_FALLBACK_SPAN_SEC)
+			chapterLabel = 'Around playhead'
+		}
+
+		let items = sorted.filter((i) => itemEnd(i) >= t0 && i.timelineStart <= t1)
+		if (items.length > MAX_WINDOW_ITEMS) {
+			items = [...items]
+				.sort((a, b) => Math.abs(a.timelineStart - playheadSec) - Math.abs(b.timelineStart - playheadSec))
+				.slice(0, MAX_WINDOW_ITEMS)
+				.sort(byStart)
+		}
+		return {
+			kind: 'chapter',
+			label: `${chapterLabel} · ${items.length} items`,
+			itemIds: items.map((i) => i.id),
+			assetIds: assetsOf(items, mediaIds)
+		}
+	}
+
+	// 4. Full timeline
+	return fullScope(sorted, mediaIds)
+}
+
+function fullScope(sorted: TimelineItem[], mediaIds: string[]): AiScope {
+	return {
+		kind: 'full',
+		label: `Whole timeline · ${sorted.length} item${sorted.length === 1 ? '' : 's'}`,
+		itemIds: sorted.map((i) => i.id),
+		assetIds: assetsOf(sorted, mediaIds)
+	}
+}
diff --git a/src/shared/timeline.ts b/src/shared/timeline.ts
new file mode 100644
index 0000000..0148e44
--- /dev/null
+++ b/src/shared/timeline.ts
@@ -0,0 +1,305 @@
+import type { Clip, MediaAsset, TimelineDiff, TimelineItem, Track } from './types'
+
+/**
+ * Pure timeline helpers shared by renderer (manual editing, undo/redo) and
+ * main (M3 AI-diff validation). No Electron / Node imports allowed here.
+ * Canonical time unit: seconds.
+ */
+
+export const TIMELINE_DIFF_SCHEMA_VERSION = 1
+
+export const MIN_ITEM_DURATION = 0.05
+export const MIN_SPEED = 0.25
+export const MAX_SPEED = 4
+
+export interface TimelineState {
+	tracks: Track[]
+	timeline: TimelineItem[]
+}
+
+export const clampSpeed = (speed: number): number =>
+	Math.min(MAX_SPEED, Math.max(MIN_SPEED, speed))
+
+/** On-timeline duration of an item: (out - in) / speed. */
+export const itemDuration = (item: Pick<TimelineItem, 'in' | 'out' | 'speed'>): number =>
+	(item.out - item.in) / (item.speed || 1)
+
+export const itemEnd = (item: TimelineItem): number =>
+	item.timelineStart + itemDuration(item)
+
+export const computeContentEnd = (items: TimelineItem[]): number =>
+	items.reduce((end, item) => Math.max(end, itemEnd(item)), 0)
+
+let uidCounter = 0
+const uid = (): string =>
+	`ti-${Date.now().toString(36)}-${(uidCounter++).toString(36)}-${Math.floor(Math.random() * 1e6).toString(36)}`
+
+/** Place a WHOLE asset on a track as one full-span item (drag the file in). */
+export function itemFromAsset(
+	asset: { id: string; name: string; metadata?: { duration?: number } },
+	trackId: string,
+	timelineStart: number,
+	durationOverride?: number
+): TimelineItem {
+	const duration = durationOverride ?? asset.metadata?.duration ?? 0
+	return {
+		id: uid(),
+		trackId,
+		sourceAssetId: asset.id,
+		timelineStart,
+		in: 0,
+		out: duration,
+		speed: 1.0,
+		preservePitch: true,
+		duration,
+		label: asset.name
+	}
+}
+
+/** Place a detected Clip (scene piece) on a track (PRD §6). */
+export function clipToItem(clip: Clip, trackId: string, timelineStart: number): TimelineItem {
+	return {
+		id: uid(),
+		trackId,
+		sourceAssetId: clip.sourceAssetId,
+		sourceClipId: clip.id,
+		masterSegmentIndex: clip.masterSegmentIndex,
+		timelineStart,
+		in: clip.in,
+		out: clip.out,
+		speed: 1.0,
+		preservePitch: true,
+		duration: clip.duration,
+		label: clip.visual?.slice(0, 40) || `Piece #${clip.index}`
+	}
+}
+
+// Fields compared per-entity when diffing (id is the key, not a field).
+const ITEM_FIELDS: (keyof TimelineItem)[] = [
+	'trackId', 'sourceAssetId', 'sourceClipId', 'masterSegmentIndex',
+	'timelineStart', 'in', 'out', 'speed', 'preservePitch', 'duration',
+	'label', 'gain', 'muted'
+]
+const TRACK_FIELDS: (keyof Track)[] = ['kind', 'name', 'order', 'muted', 'locked', 'hidden', 'height']
+
+function changedFields<T extends { id: string }>(before: T, after: T, fields: (keyof T)[]): Partial<T> | null {
+	let changed: Partial<T> | null = null
+	for (const field of fields) {
+		if (before[field] !== after[field]) {
+			if (!changed) changed = {}
+			changed[field] = after[field]
+		}
+	}
+	return changed
+}
+
+function pickFields<T extends { id: string }>(source: T, keys: (keyof T)[]): Partial<T> {
+	const out: Partial<T> = {}
+	for (const key of keys) out[key] = source[key]
+	return out
+}
+
+/**
+ * Snapshot-based diff: compares whole timeline states by entity id and
+ * produces a forward diff (before -> after) plus its exact inverse.
+ * Returns null when nothing changed.
+ */
+export function diffTimelines(
+	before: TimelineState,
+	after: TimelineState
+): { forward: TimelineDiff; inverse: TimelineDiff } | null {
+	const forward: TimelineDiff = { schemaVersion: TIMELINE_DIFF_SCHEMA_VERSION }
+	const inverse: TimelineDiff = { schemaVersion: TIMELINE_DIFF_SCHEMA_VERSION }
+	let dirty = false
+
+	// --- Items ---
+	const beforeItems = new Map(before.timeline.map((i) => [i.id, i]))
+	const afterItems = new Map(after.timeline.map((i) => [i.id, i]))
+
+	for (const [id, afterItem] of afterItems) {
+		const beforeItem = beforeItems.get(id)
+		if (!beforeItem) {
+			;(forward.addItems ||= []).push({ ...afterItem })
+			;(inverse.removeItemIds ||= []).push(id)
+			dirty = true
+		} else {
+			const fwd = changedFields(beforeItem, afterItem, ITEM_FIELDS)
+			if (fwd) {
+				const keys = Object.keys(fwd) as (keyof TimelineItem)[]
+				;(forward.updateItems ||= []).push({ id, ...fwd })
+				;(inverse.updateItems ||= []).push({ id, ...pickFields(beforeItem, keys) })
+				dirty = true
+			}
+		}
+	}
+	for (const [id, beforeItem] of beforeItems) {
+		if (!afterItems.has(id)) {
+			;(forward.removeItemIds ||= []).push(id)
+			;(inverse.addItems ||= []).push({ ...beforeItem })
+			dirty = true
+		}
+	}
+
+	// --- Tracks ---
+	const beforeTracks = new Map(before.tracks.map((t) => [t.id, t]))
+	const afterTracks = new Map(after.tracks.map((t) => [t.id, t]))
+
+	for (const [id, afterTrack] of afterTracks) {
+		const beforeTrack = beforeTracks.get(id)
+		if (!beforeTrack) {
+			;(forward.addTracks ||= []).push({ ...afterTrack })
+			;(inverse.removeTrackIds ||= []).push(id)
+			dirty = true
+		} else {
+			const fwd = changedFields(beforeTrack, afterTrack, TRACK_FIELDS)
+			if (fwd) {
+				// Track updates ride through add/remove pairs is wrong — TimelineDiff
+				// has no updateTracks op, so encode as remove+add of the SAME id.
+				// Order matters on apply: removals run before adds.
+				;(forward.removeTrackIds ||= []).push(id)
+				;(forward.addTracks ||= []).push({ ...afterTrack })
+				;(inverse.removeTrackIds ||= []).push(id)
+				;(inverse.addTracks ||= []).push({ ...beforeTrack })
+				dirty = true
+			}
+		}
+	}
+	for (const [id, beforeTrack] of beforeTracks) {
+		if (!afterTracks.has(id)) {
+			;(forward.removeTrackIds ||= []).push(id)
+			;(inverse.addTracks ||= []).push({ ...beforeTrack })
+			dirty = true
+		}
+	}
+
+	return dirty ? { forward, inverse } : null
+}
+
+export interface ApplyResult {
+	ok: boolean
+	errors: string[]
+}
+
+/**
+ * Repairs same-track overlaps by pushing later items right until sequential
+ * (magnetic, content-preserving). Returns true when anything moved.
+ * Needed because AI-diff placements aren't gesture-clamped like manual moves.
+ */
+export function repairOverlaps(state: TimelineState, eps = MIN_ITEM_DURATION): boolean {
+	let changed = false
+	const byTrack = new Map<string, TimelineItem[]>()
+	for (const item of state.timeline) {
+		const list = byTrack.get(item.trackId) || []
+		list.push(item)
+		byTrack.set(item.trackId, list)
+	}
+	for (const items of byTrack.values()) {
+		items.sort((a, b) => a.timelineStart - b.timelineStart)
+		let cursor = 0
+		for (const item of items) {
+			if (item.timelineStart < cursor - eps) {
+				item.timelineStart = cursor
+				changed = true
+			}
+			cursor = Math.max(cursor, itemEnd(item))
+		}
+	}
+	return changed
+}
+
+/**
+ * Applies a TimelineDiff to a state IN PLACE, with validation (PRD §5.7):
+ * unknown schemaVersion rejected wholesale; unknown ids skipped (reported);
+ * `0 <= in < out <= asset.duration` when assets provided; speed clamped;
+ * `duration` recomputed as (out - in) / speed — never taken from the diff.
+ */
+export function applyTimelineDiff(
+	state: TimelineState,
+	diff: TimelineDiff,
+	assets?: MediaAsset[]
+): ApplyResult {
+	const errors: string[] = []
+
+	if (diff.schemaVersion !== TIMELINE_DIFF_SCHEMA_VERSION) {
+		return { ok: false, errors: [`Unknown TimelineDiff schemaVersion ${diff.schemaVersion}`] }
+	}
+
+	const assetById = new Map((assets || []).map((a) => [a.id, a]))
+
+	const validateRange = (item: Pick<TimelineItem, 'sourceAssetId' | 'in' | 'out'>): string | null => {
+		if (item.in < 0 || item.out <= item.in) {
+			return `invalid range in=${item.in} out=${item.out}`
+		}
+		const asset = assetById.get(item.sourceAssetId)
+		if (asset?.metadata?.duration && item.out > asset.metadata.duration + 0.01) {
+			return `out=${item.out} exceeds asset duration ${asset.metadata.duration}`
+		}
+		return null
+	}
+
+	const normalize = (item: TimelineItem): TimelineItem => {
+		const speed = clampSpeed(item.speed || 1)
+		return { ...item, speed, duration: (item.out - item.in) / speed }
+	}
+
+	// Removals before additions (track-update encoding relies on this order).
+	if (diff.removeTrackIds?.length) {
+		const ids = new Set(diff.removeTrackIds)
+		state.tracks = state.tracks.filter((t) => !ids.has(t.id))
+	}
+	if (diff.addTracks?.length) {
+		for (const track of diff.addTracks) {
+			if (state.tracks.some((t) => t.id === track.id)) {
+				errors.push(`addTracks: duplicate id ${track.id}`)
+				continue
+			}
+			state.tracks.push({ ...track })
+		}
+		state.tracks.sort((a, b) => a.order - b.order)
+	}
+
+	if (diff.removeItemIds?.length) {
+		const ids = new Set(diff.removeItemIds)
+		const known = state.timeline.filter((i) => ids.has(i.id)).length
+		if (known !== ids.size) errors.push(`removeItemIds: ${ids.size - known} unknown id(s) skipped`)
+		state.timeline = state.timeline.filter((i) => !ids.has(i.id))
+	}
+
+	if (diff.addItems?.length) {
+		for (const item of diff.addItems) {
+			if (state.timeline.some((i) => i.id === item.id)) {
+				errors.push(`addItems: duplicate id ${item.id} skipped`)
+				continue
+			}
+			const rangeError = validateRange(item)
+			if (rangeError) {
+				errors.push(`addItems ${item.id}: ${rangeError}`)
+				continue
+			}
+			if (!state.tracks.some((t) => t.id === item.trackId)) {
+				errors.push(`addItems ${item.id}: unknown track ${item.trackId}`)
+				continue
+			}
+			state.timeline.push(normalize({ ...item }))
+		}
+	}
+
+	if (diff.updateItems?.length) {
+		for (const update of diff.updateItems) {
+			const index = state.timeline.findIndex((i) => i.id === update.id)
+			if (index === -1) {
+				errors.push(`updateItems: unknown id ${update.id} skipped`)
+				continue
+			}
+			const merged = { ...state.timeline[index], ...update }
+			const rangeError = validateRange(merged)
+			if (rangeError) {
+				errors.push(`updateItems ${update.id}: ${rangeError}`)
+				continue
+			}
+			state.timeline[index] = normalize(merged)
+		}
+	}
+
+	return { ok: errors.length === 0, errors }
+}
diff --git a/src/shared/types.ts b/src/shared/types.ts
index bd441b3..89b77d1 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -70,10 +70,12 @@ export interface Message {
 	createdAt: number;
 }
 
+export type ThreadType = 'video' | 'image' | 'editor'
+
 export interface Thread {
 	id: string
 	title: string
-	type?: 'video' | 'image' // New
+	type?: ThreadType
 	videoPath?: string // Now optional
 	preprocessing: {
 		/**
@@ -158,10 +160,287 @@ export interface Thread {
 	videoMetadata?: VideoMetadata
 	usageHistory?: UsageRecord[]
 	missing?: boolean
+	/** Present only when type === 'editor' — the timeline editor document. */
+	editor?: EditorDocument
 	createdAt: number
 	updatedAt: number
 }
 
+// ============================================================
+// Timeline Video Editor (see video-editor-prd.md §6)
+// Canonical time unit is SECONDS. SRT strings only appear at the
+// boundary with legacy generateTimeline/assembleVideo.
+// ============================================================
+
+export interface EditorDocument {
+	schemaVersion: 1
+	media: MediaAsset[]         // imported sources
+	tracks: Track[]             // lane definitions
+	timeline: TimelineItem[]    // placements across tracks — the live EDL
+	timelineMeta: TimelineMeta
+	activePersonaId: string
+	customPersonas?: EditorPersona[]  // project-local personas
+	turns: PromptTurn[]         // prompt-request log (no snapshots)
+	historyRef: EditorHistoryRef      // pointer into the sidecar history file
+	selection?: { clipIds?: string[]; itemIds?: string[] }
+	markers?: EditorMarker[]    // renderer-owned; NOT undoable (outside TimelineDiff)
+	/** Pointer into the revisions sidecar (userData/editor-revisions/{id}.json). */
+	currentRevisionId?: string
+}
+
+export interface TimelineMeta {
+	fps: number
+	width: number
+	height: number
+	duration: number            // seconds; derived = max(item.timelineStart + item.duration)
+	aspectRatio?: string        // "16:9" | "9:16"
+}
+
+export type MediaKind = 'video' | 'image' | 'audio'
+
+export type MediaPreprocessState = 'pending' | 'running' | 'completed' | 'error'
+
+export interface MediaAsset {
+	id: string
+	kind: MediaKind
+	name: string
+	originalPath: string        // absolute; served via media://
+	proxyPath?: string          // 480p proxy === lowResVideoPath
+	metadata?: VideoMetadata
+	/** Reuses the EXACT shape of Thread['preprocessing'] so existing phases run per-asset. */
+	preprocessing: Thread['preprocessing']
+	preprocessTasks?: Record<string, BackgroundTask>
+	preprocessState?: MediaPreprocessState
+	preprocessError?: string
+	clips: Clip[]               // derived from scene detection
+	filmstrip?: FilmstripEntry[]
+	createdAt: number
+}
+
+export interface FilmstripEntry { time: number; thumbnailPath: string }
+
+export interface Clip {        // a selectable scene piece
+	id: string
+	sourceAssetId: string
+	index: number               // 1-based, mirrors Scene/EnrichedTimelineSegment ordering
+	in: number                  // seconds into source (Scene.startTime)
+	out: number                 // seconds into source (Scene.endTime)
+	duration: number            // out - in
+	thumbnailPath?: string
+	visual?: string             // === EnrichedTimelineSegment.visual — context-preview text
+	text?: string               // transcript excerpt overlapping [in,out]
+	selected: boolean           // media-panel multi-select
+	masterSegmentIndex?: number // back-reference into the enriched master timeline
+}
+
+export type TrackKind = 'video' | 'audio' | 'overlay' | 'text'
+
+export interface Track {
+	id: string
+	kind: TrackKind             // 'overlay' | 'text' = "other objects for later"
+	name: string
+	order: number               // stacking order (0 = bottom video)
+	muted: boolean
+	locked: boolean
+	hidden: boolean
+	height: number              // px in the timeline UI
+}
+
+export interface TimelineItem {  // an instance of a clip placed on a track
+	id: string
+	trackId: string
+	sourceAssetId: string
+	sourceClipId?: string       // set when dragged from a detected Clip
+	masterSegmentIndex?: number // present only for a whole, un-split master scene
+	timelineStart: number       // seconds on the sequence timeline
+	in: number                  // seconds into source (trim start)
+	out: number                 // seconds into source (trim end)
+	speed: number               // constant playback rate (default 1.0); retime tool
+	preservePitch: boolean      // default true — audio retimed with atempo keeps pitch
+	duration: number            // ON-TIMELINE duration = (out - in) / speed
+	label?: string
+	gain?: number               // audio gain multiplier (default 1.0)
+	muted?: boolean
+	// ---- Stubs (deferred: effects/transitions/transforms/text) ----
+	transform?: TimelineItemTransform
+	effects?: EffectRef[]
+	transition?: { in?: TransitionRef; out?: TransitionRef }
+	text?: TextOverlaySpec
+}
+
+export interface TimelineItemTransform { x?: number; y?: number; scale?: number; rotation?: number }
+export interface EffectRef { id: string; kind: string; params?: Record<string, unknown> } // stub
+export interface TransitionRef { kind: string; duration: number }                          // stub
+export interface TextOverlaySpec { content: string; style?: Record<string, unknown> }      // stub
+
+export interface EditorPersona {
+	id: string
+	name: string
+	icon: string                // emoji or Tabler icon id
+	description: string
+	systemPrompt: string        // the whole backing for v1
+	builtin: boolean            // seeded personas can't be deleted, only cloned
+	tone?: string
+	mode?: 'longform' | 'summarize'
+	defaults?: { targetDurationSec?: number | null; aspectRatio?: string; pacing?: 'tight' | 'balanced' | 'relaxed' }
+	featureSets?: FeatureSetRef[]  // deferred; always [] in v1
+}
+
+export interface FeatureSetRef { id: string; name: string } // stub
+
+export interface EditorHistoryRef {
+	currentStepId: string       // undo/redo pointer (persisted with the doc → undo survives restart)
+	stepCount: number
+}
+
+export interface EditorMarker {
+	id: string
+	time: number                // seconds on the sequence timeline
+	label?: string
+}
+
+/** A low-energy region in a source asset (seconds into the source), from ffmpeg silencedetect. */
+export interface SilenceRegion {
+	start: number
+	end: number
+}
+
+// ---- Undo/redo sidecar file: userData/editor-history/{threadId}.json ----
+// Kept OUT of threads/{id}.json so the debounced doc autosave never rewrites
+// history, and history growth never bloats the doc (PRD §6).
+export interface EditorHistoryFile {
+	threadId: string
+	steps: EditorHistoryStep[]     // ring buffer, MAX_STEPS = 50
+	keyframes: TimelineSnapshot[]  // sparse; every K = 10 steps, bounds replay cost
+	currentStepId: string          // informational — the pointer of record is doc.historyRef
+}
+
+export interface EditorHistoryStep {
+	id: string
+	seq: number                 // monotonic (Thread.versionCounter via getNextVersion)
+	origin: 'init' | 'ai' | 'manual'
+	label?: string
+	forward: TimelineDiff       // apply to go newer
+	inverse: TimelineDiff       // apply to undo
+	turnId?: string             // set when origin === 'ai'
+	createdAt: number
+}
+
+export interface TimelineSnapshot {
+	stepId: string              // state AFTER this step was applied
+	tracks: Track[]
+	timeline: TimelineItem[]
+	timelineMeta: TimelineMeta
+}
+
+// ===== Revision tree (coarse, permanent checkpoints above the undo ring) =====
+
+export type RevisionOrigin = 'init' | 'ai' | 'manual'
+
+/**
+ * One node of the revision tree. Snapshots are FULL and self-contained —
+ * never diff-chained into the undo ring (the ring evicts steps: MAX 50 +
+ * redo-branch truncation), so a revision must always restore standalone.
+ */
+export interface EditorRevision {
+	id: string
+	parentId: string | null     // null only for the root 'init' revision
+	seq: number                 // sidecar revisionCounter; displayed "V{seq}"
+	origin: RevisionOrigin
+	label: string               // persona name / user label / 'Original' / 'Auto checkpoint'
+	turnId?: string             // origin === 'ai'
+	personaId?: string          // origin === 'ai' — drives the list-item icon
+	snapshot: {
+		tracks: Track[]
+		timeline: TimelineItem[]
+		timelineMeta: TimelineMeta
+		markers?: EditorMarker[]  // markers ride in the snapshot so switches restore them
+	}
+	createdAt: number
+}
+
+// ---- Revisions sidecar: userData/editor-revisions/{threadId}.json ----
+export interface EditorRevisionsFile {
+	threadId: string
+	schemaVersion: 1
+	revisionCounter: number     // max-ever; V numbers never reused after deletes
+	revisions: EditorRevision[]
+}
+
+export interface PromptTurn {
+	id: string
+	personaId: string
+	prompt: string
+	baseStepId: string
+	resultStepId?: string
+	status: 'pending' | 'running' | 'completed' | 'error'
+	error?: string
+	diff?: TimelineDiff
+	rationale?: string
+	answer?: string             // set when the request was a question, not an edit
+	droppedOps?: string[]       // ops pruned during validation (surfaced on the card)
+	scopeLabel?: string         // e.g. "Chapter 3 · 12 items"
+	revisionId?: string         // revision created from this turn's applied diff
+	usage?: Usage
+	cost?: number
+	createdAt: number
+}
+
+/**
+ * Constrained edit-operation schema the AI model returns (M3).
+ * Deliberately NOT a raw TimelineDiff: item ids for adds are generated
+ * server-side, durations are never model-set, and adds reference assets +
+ * scene numbers from the provided context. Mapped to TimelineDiff by
+ * opsToDiff() in src/main/editor/prompt.ts.
+ */
+export interface EditorOps {
+	answer?: string
+	rationale?: string
+	removeItemIds?: string[]
+	updateItems?: Array<{
+		id: string
+		timelineStart?: number
+		in?: number
+		out?: number
+		speed?: number
+		label?: string
+	}>
+	addClips?: Array<{
+		assetId: string
+		sceneIndex?: number       // preferred: a scene # from AVAILABLE SCENES
+		in?: number               // alternative: explicit source range
+		out?: number
+		atSec?: number            // placement (optional)
+		afterItemId?: string
+		label?: string
+	}>
+	addMarkers?: Array<{ atSec: number; label: string }>
+}
+
+export type TimelineDiff = {
+	schemaVersion: number
+	addItems?: TimelineItem[]
+	removeItemIds?: string[]
+	updateItems?: Array<{ id: string } & Partial<TimelineItem>>
+	addTracks?: Track[]
+	removeTrackIds?: string[]
+}
+
+// ===== Export / render (M4) =====
+
+export type ExportQuality = 'original' | 'preview'
+
+export type RenderPhase = 'rendering' | 'stitching' | 'done' | 'error'
+
+export interface EditorRenderProgress {
+	threadId: string
+	renderId: string
+	percent: number
+	phase: RenderPhase
+	outputPath?: string
+	error?: string
+}
+
 export interface TimelineSegment {
 	index: number
 	start: string
@@ -198,7 +477,7 @@ export interface ModelPricing {
 	}
 }
 
-export type OperationType = 'raw-transcript' | 'corrected-transcript' | 'intent' | 'timeline-new' | 'timeline-edit' | 'thumbnail' | 'scene-description' | 'image-extraction' | 'image-intent' | 'image-generation' | 'image-upscale'
+export type OperationType = 'raw-transcript' | 'corrected-transcript' | 'intent' | 'timeline-new' | 'timeline-edit' | 'thumbnail' | 'scene-description' | 'image-extraction' | 'image-intent' | 'image-generation' | 'image-upscale' | 'editor-edit'
 
 export type UpscaleFactor = 'x2' | 'x4'
 
diff --git a/tailwind.config.js b/tailwind.config.js
index 62b1d0f..8f7b6ac 100644
--- a/tailwind.config.js
+++ b/tailwind.config.js
@@ -38,13 +38,21 @@ export default {
       animation: {
         'fade-in-up': 'fadeInUp 0.5s ease-out',
         'fade-in': 'fadeIn 0.5s ease-out',
+        'menu': 'menuIn 0.12s ease-out',
         'pulse-soft': 'pulseSoft 2s infinite ease-in-out',
+        'indeterminate': 'indeterminate 1.2s infinite ease-in-out',
       },
       keyframes: {
         fadeInUp: {
           '0%': { opacity: '0', transform: 'translateY(10px)' },
           '100%': { opacity: '1', transform: 'translateY(0)' },
         },
+        // Snappy dropdown/popover entrance: quick fade + faint scale from
+        // the anchor edge (pair with origin-top / origin-bottom).
+        menuIn: {
+          '0%': { opacity: '0', transform: 'scale(0.97)' },
+          '100%': { opacity: '1', transform: 'scale(1)' },
+        },
         fadeIn: {
           '0%': { opacity: '0' },
           '100%': { opacity: '1' },
@@ -53,6 +61,10 @@ export default {
           '0%, 100%': { opacity: '1' },
           '50%': { opacity: '0.8' },
         },
+        indeterminate: {
+          '0%': { transform: 'translateX(-100%)' },
+          '100%': { transform: 'translateX(100%)' },
+        },
       },
     },
   },
diff --git a/video-editor-prd.md b/video-editor-prd.md
new file mode 100644
index 0000000..5c6907b
--- /dev/null
+++ b/video-editor-prd.md
@@ -0,0 +1,932 @@
+# FrameFlow — Timeline Video Editor PRD
+
+FrameFlow today edits video through a single surface: an AI-driven node-graph "chat editor" where the user talks to Gemini, the model writes a timeline blueprint, and FFmpeg assembles a single-source cut. This PRD specifies a **second, coexisting surface** — a traditional CapCut/Premiere/DaVinci-style **timeline video editor** with a media browser, a program monitor, a multi-track timeline, direct manual editing, and a prompt box driven by swappable AI **editor personas**. It reuses FrameFlow's existing scene-detection, per-scene visual-description enrichment, background-task, `media://` playback, and thread-persistence machinery, while introducing a per-media preprocessing model, a timeline document, a persona library, and — the single largest new engineering lift — a multi-source/multi-track FFmpeg render engine that the current single-source `assembleVideo` cannot provide.
+
+| | |
+|---|---|
+| **Status** | v1 shipped & verified (M0–M4) + revisions rework + v1-completion round — on branch `feat/video-editor-m0-m1`; only audio-kind assets remain |
+| **Owner** | navidshad72@gmail.com |
+| **Date** | 2026-07-18 (status updated as of implementation) |
+| **App** | FrameFlow (Electron + Vue 3 + Vite, TypeScript) |
+| **Feature** | Traditional timeline video editor (new surface, alongside the AI graph editor) |
+
+---
+
+## 0. Implementation Status
+
+v1 was delivered in five milestones and all 8 requested features are live and user-verified. One post-v1 rework replaced the AI review flow (§5.7) with a branchable **revision tree**.
+
+**Shipped (commits on `feat/video-editor-m0-m1`):**
+
+| Milestone | Commit | What landed |
+|---|---|---|
+| M0+M1 | `b9fa93f` | Editor route/shell, media import (local + URL), per-asset preprocessing, scene-split into selectable pieces |
+| M2 | `4a499e6` | Multi-track timeline (drag/trim/split/ripple/retime/snap/zoom/markers), EDL preview, filmstrip⇄context toggle, sidecar undo/redo, keyboard map |
+| M3 | `f11e400` | AI prompt bar, 9 personas (long-form + summarize) + user personas, `EditorOps`→`TimelineDiff`, full context windowing |
+| M4 | `5dfca7b` | Export: `assembleVideo` fast path + `assembleTimeline` segment-then-concat (retime, gaps, mutes, source-derived normalization) |
+| Revisions | `68225ae` | **Replaces §5.7's accept/reject flow** — AI results apply immediately as branchable revisions (list + Vue Flow graph), manual checkpoints, full-snapshot sidecar |
+
+**v1-completion round (2026-07-19, verified live via Playwright against a synthetic speech/silence video):**
+
+| Item | Commit | What landed |
+|---|---|---|
+| Per-asset transcript (§5.2) | `d96319f` | Opt-in `audio`+`transcript` preprocess steps reusing the chat extraction phases per-asset; excerpts merged into `Clip.text` by time overlap; "Transcribe" button in the Inspector |
+| Silence/dead-air finder (§5.6) | `d96319f` | `detectSilence` (`silencedetect`) + `find-silence` IPC; tunable noise-floor/min-duration; reviewable region list (persists across Inspector modes) applying as one undoable ripple-delete |
+| Sensitivity slider + merge/split (§5.2) | `7ab6371` | ClipTray detector panel (threshold 5–60 + re-detect) and adjacency-validated merge / midpoint split of pieces (main-owned clip mutations) |
+| Minimap + marker jump list (§5.3) | `99af7b8` | Always-visible overview strip (item blocks, marker ticks, playhead, draggable window rect) + toolbar Markers & chapters popover with jump/remove |
+| Dense filmstrip (§5.5) | `2975983` | Single-pass batched extractor (`fps=1/interval`, ≤300 frames/asset) populating `MediaAsset.filmstrip`; TimelineClip tiles one lazy frame per ~64px, zoom-adaptive |
+| `prefers-reduced-motion` (§5.11) | `0eeb023` | Global media query suppressing decorative animation; playback/playhead untouched |
+
+**Not yet built — the one v1-scope item remaining:**
+- **Audio-kind assets** (§5.1/§5.4) — `MediaAsset.kind` is always `'video'`; the A1 lane can't yet receive imported audio. Scoped for its own milestone in two halves: (a) import + drop/move UI, and (b) the export refactor — `computeRegions` (`render.ts`) slices regions only at *video*-item boundaries with 0..1 audio sources per region, so real mixing needs slicing at audio-item boundaries too and a k>1 `amix` graph per §5.9.
+
+**Deferred by design (v2 / M5 non-goals, never promised for v1):** overlay/text authoring, effects & transitions engine, persona feature-sets (feature 8's full form — `featureSets` stub + registries in place), true multi-track compositing / PiP / simultaneous `amix` (region model is amix-ready), pro trims (roll/slip/slide/JKL, 3-point, nested sequences), keyframed speed ramps, word-level filler removal, a first-class `Chapter[]` model (Open Q12, recommended for v1.1).
+
+---
+
+## 1. Overview & Motivation
+
+**What this is.** A new, full-bleed editor page (route `/editor/:id`) reachable from a "Video Editor" tile on the Home grid. It presents the layout professionals already know — a media/browser panel on the left, a large preview/program monitor in the center, an inspector on the right, and a multi-track timeline across the bottom — plus a docked prompt bar carrying a selectable AI persona. The user imports one or more videos, FrameFlow breaks each into selectable scene "pieces," the user drags pieces onto tracks or asks a persona to build/refine the edit by prompt, and finally exports a rendered file.
+
+**It is length-agnostic.** This editor is **not** a summarizer. It targets full-length editorial work as much as short cuts: a 3-minute highlight *and* a 90-minute podcast, a vlog, a webinar, or a lecture kept at (or near) full length. A summary is just one possible output; the more common long-form goals are *cleaning* (remove filler/silence/dead air), *retiming* (speed a section up or slow it down), *reordering*, *chaptering*, and *trimming* — all without necessarily shortening the whole piece. Everything below (scene splitting, personas, budgets, AI context) is designed so a multi-hour timeline works, not only a short one (see the scalability treatment in §8).
+
+**Why add it alongside the graph editor.** The existing graph editor (`src/renderer/src/pages/GraphChatPage.vue`) is outcome-oriented: you describe what you want and Gemini decides the whole cut. It is excellent for "summarize this lecture to 3 minutes," but it offers **no direct manipulation** — no dragging a clip, trimming a frame, muting a track, or placing two sources side by side. Real editing work needs a spatial, manual surface where time runs left→right and parallel content stacks as tracks. Rather than bolt manual controls onto the node graph (Vue Flow is the wrong interaction model for a 1-D timeline — see §7), we add a purpose-built editor that treats the timeline as a shared document both the human and the AI mutate.
+
+**Who it is for.**
+- **Long-form editors** — podcasters, vloggers, course/webinar creators, streamers cutting VODs — who keep most of the runtime and want to *tighten* it: remove filler and silence, retime slow stretches, reorder segments, add chapters. This is the primary audience, and the personas and budgets below are shaped for it.
+- **Summarization users** who like FrameFlow's AI cuts but want to hand-tweak the result (nudge a boundary, drop one more scene, reorder).
+- **Prosumer editors** who expect a familiar NLE layout and manual tools, but want an AI co-editor on tap.
+- **Semantic editors** — FrameFlow's differentiator: every selectable piece already carries a one-line **visual description** (`EnrichedTimelineSegment.visual`), so users can see and reason about clips by meaning, not just thumbnails — which matters most on a long timeline where thumbnails alone are hard to scan.
+
+The two paradigms stay cleanly separated by a single `Thread.type` discriminator and separate routes; they share persistence, preprocessing, background tasks, and the Gemini pipeline.
+
+---
+
+## 2. Goals & Non-Goals
+
+### Goals (v1)
+- Ship a CapCut/Premiere-style four-zone layout (browser, monitor, timeline, inspector) that reads as a real editor **(feature 1)**.
+- **Serve full-length editorial work, not only summaries** — a multi-hour podcast/vlog/webinar can be imported, cleaned, retimed, reordered, and chaptered while keeping most of its runtime.
+- Media panel to add local files and URL/YouTube imports; each imported video runs the existing preprocessing steps and is auto-split into selectable scene pieces **(feature 2)**.
+- Preview/program monitor and a multi-track timeline; drag pieces from the browser onto tracks **(feature 3)**.
+- Timeline view toggle: **frames-preview** (thumbnail filmstrip) ⇄ **context-preview** (per-scene visual/text descriptions) **(feature 4)**.
+- Track types: **video**, **audio**, and **overlay/"other objects"** lanes present in the model and UI (overlay items inert in v1) **(feature 5)**.
+- A prompt box for AI-driven edits **and** first-class manual editing, sharing one timeline document **(feature 6)**. Manual tools include **section timing control** — trim, ripple-trim, **cut (split + delete)**, and **retime/speed** to reduce *or extend* a section's on-timeline duration, plus move, snap, and zoom.
+- **Constant per-clip speed (retime)** so a section can be sped up (compress a slow stretch) or slowed down (stretch it out), with a numeric target-duration entry per item. (Keyframed *speed ramps* remain deferred — see non-goals.)
+- Editor **personas** covering **both long-form editorial and summarization**: predefined (read-only, cloneable) + user-defined; each persona is a system-prompt/text profile for v1 **(feature 7)**.
+- Persona schema forward-compatible with future **feature-sets**, present as a typed stub **(feature 8)**.
+- Full keyboard-driven editing plus baseline accessibility for the timeline canvas (§5.11).
+- Export a rendered file (any length), reusing the existing single-source fast path where the timeline is degenerate and introducing a multi-source render path incrementally.
+- **Scale to long content:** virtualized timeline/clip tray, lazy filmstrips, opt-in enrichment, and **windowed AI context** so a multi-hour project stays responsive and stays within the model's context window (§8).
+
+### Non-Goals (v1 — explicitly deferred)
+- **Full NLE multi-track compositing.** v1 renders a single primary video track (+ a mixed audio output) robustly; PiP overlay stacking, per-clip transforms, and blend/opacity are P2+ (§9 M5).
+- **Effects & transitions engine.** No LUTs, filters, color grading, `xfade`/`acrossfade` transitions, or keyframing. `TimelineItem.effects/transition/transform` ship as typed stubs only. **Exception:** a single **constant per-clip speed** (`TimelineItem.speed`, applied via `setpts`/`atempo` at export) *is* in v1 — it's the retime control (§5.6); keyframed/animated **speed ramps** are the part that stays deferred.
+- **Silence/filler auto-removal as a fully automatic pass.** v1 offers silence detection as an *assistive* auto-cut the user reviews (§5.6), not a one-click destructive "clean the whole podcast" batch; transcript-word-level filler removal ("um"/"uh") is deferred to v2 with the effects engine.
+- **Persona feature-sets.** Personas are text (system prompt + a few typed defaults) in v1. `featureSets` is a stubbed `[]` — no effect-group binding **(feature 8 is explicitly deferred beyond the schema stub)**.
+- **Pro trim modes.** No roll/slip/slide, no separate source monitor with full 3-point editing, no JKL/dynamic trimming, no nested sequences. (Split, drag-trim, ripple-delete, snap, zoom are in.)
+- **Collaboration / multi-user / cloud sync.** Local desktop, single user, single project at a time.
+- **Real-time composited scrubbing preview.** The monitor previews via EDL playback of proxies (single `<video>` switching at clip boundaries), not a live ffmpeg composite. True composited preview is out of scope; final composite happens only at export.
+- **Overlay/text authoring UI.** Overlay and text tracks exist structurally; authoring text content and styling them is deferred with the effects engine. v1 export ignores their items entirely (§5.9).
+
+---
+
+## 3. User Flows
+
+### (a) Entry from Home → provide initial files → editor opens
+1. On Home (`HomePage.vue`), the user clicks the new **"Video Editor"** `NewThreadCard`.
+2. The handler calls `window.api.createEditorProject(...)` (IPC channel `create-editor-project`) → a `ThreadManager.createThread` variant sets `type: 'editor'`, initializes the **required** fields `preprocessing: {}` and `messages: []`, leaves the (optional) `videoPath` undefined, attaches an empty `EditorDocument`, then `router.push('/editor/<id>')`.
+3. The global Gemini-API-key route guard (`router.ts:44`) applies automatically; no editor-specific guard needed.
+4. `VideoEditorPage.vue` mounts, reads `route.params.id`, and asks the user to add the first media (empty-state CTA in the media panel). Optionally, the create step can accept an initial file/URL and kick import immediately.
+
+### (b) Import more media
+1. In the media panel, click **Add media** → `window.api.selectVideo()` (channel `select-video`) / `window.api.showOpenDialog()` (channel `show-open-dialog`) for local files, or paste a URL → `window.api.importMediaUrl(...)` (channel `import-media-url`, wrapping the existing `download-video` flow; emits `download-progress`).
+2. Before any scene split, the app checks dependency status via `window.api.getDependencyStatus()` (channel `get-dependency-status`); if `scenedetect`/`ffmpeg` are missing it surfaces the existing install flow (§5.10) rather than failing.
+3. The file is copied into `tempDir/media/<assetId>/`; `window.api.getVideoMetadata()` (channel `get-video-metadata`) probes it; a `MediaAsset` is pushed and per-asset preprocessing starts.
+
+### (c) Auto-break into pieces & select
+1. Per-asset preprocessing (background tasks) runs: 480p proxy → audio → transcript → **scene detection** → per-scene visual descriptions → enrichment. Live status shows per step.
+2. Detected scenes become `Clip[]` (one selectable "piece" per scene, with thumbnail + `visual` + transcript excerpt).
+3. The user browses pieces in the clip tray, multi-selects, filters by description text, and optionally adjusts detector sensitivity / merges or splits scenes.
+
+### (d) Build timeline manually
+1. Drag a piece (or a multi-selection) from the tray onto a track; a `TimelineItem` is placed at the drop time. A keyboard-only placement path exists (§5.11).
+2. Trim edges, split at playhead (razor), move, ripple-delete, snap to edges/playhead/scene boundaries, zoom the time axis.
+
+### (e) Prompt-driven edit with a persona
+1. Pick a persona in the prompt bar (e.g. *Concise Summarizer*), type an instruction ("cut this to a 60s highlight reel").
+2. The request runs through the pipeline (`intent` → `generateTimeline` edit/new mode) with the persona's system prompt prepended; status streams via `pipeline-update`. The generator receives the **current live `items[]`** (ids + source ranges + optional `masterSegmentIndex`) as context (§5.7).
+3. The AI returns a **proposed `TimelineDiff`** keyed to those live item ids (keep/drop/reorder/add) rendered on the timeline with a rationale; the user Accepts all / Rejects all / toggles individual decisions.
+4. Accepting commits a new immutable version; the user can then hand-tweak on top; the next prompt reads the current (hand-tweaked) timeline as context.
+
+### (f) Preview
+1. The program monitor plays the composed timeline via EDL playback of 480p proxies through `media://`, driven by the playhead; transport controls scrub/seek.
+
+### (g) Export
+1. Click **Export** → `window.api.exportEditorTimeline(...)` (channel `export-editor-timeline`). If the timeline is one video track over one source, **every item is `speed === 1.0`**, and there are no overlay/text items, it maps to `TimelineSegment[]` and reuses `assembleVideo`. Otherwise (multi-source, or any retimed item) the new `assembleTimeline` multi-source path runs (segment-then-concat). If non-empty overlay/text tracks exist, the export dialog shows a one-line notice that they will not appear in the output. Progress via a `render-progress` event; abortable. Reuse `window.api.saveVideo()` (channel `save-video`) to write the final file.
+
+```mermaid
+flowchart TD
+  A[Home: Video Editor card] --> B[create-editor-project → /editor/:id]
+  B --> C[Add media: file / URL]
+  C --> Cd{scenedetect/ffmpeg installed?}
+  Cd -->|no| Ci[surface install-dependency flow]
+  Ci --> D
+  Cd -->|yes| D[Copy to tempDir/media/assetId + probe metadata]
+  D --> E[Per-asset preprocessing tasks:\nproxy → audio → transcript → scenes → descriptions → enrich]
+  E --> F[Scenes → selectable Clips\nthumb + visual + text]
+  F --> G{Build the edit}
+  G -->|Manual| H[Drag pieces to tracks\ntrim / split / move / ripple / snap / zoom]
+  G -->|Prompt + persona| I[intent → generateTimeline\npersona systemPrompt prepended\ncontext = live items with ids]
+  I --> J[Proposed TimelineDiff\nkeyed to live item ids + rationale]
+  J -->|Accept all / partial / reject| H
+  H --> K[Program monitor:\nEDL playback of 480p proxies]
+  K --> L{Export}
+  L -->|single track, single source, no retime/overlay| M[assembleVideo fast path]
+  L -->|multi-source OR any retimed item| N[assembleTimeline\nsegment-then-concat + per-region audio graph + per-item setpts/atempo]
+  M --> O[save-video → final file]
+  N --> O
+```
+
+---
+
+## 4. UI / Layout Spec  *(feature 1)*
+
+The editor uses the **full-bleed workspace** page shape (copy `GraphChatPage.vue`'s root: `h-full w-full flex flex-col relative bg-zinc-50 dark:bg-zinc-950 overflow-hidden`, two ambient blurred blobs, a flush custom header — **not** the centered `PageHeader` container). It defaults to a dark professional NLE chrome but honors the class-based dark/light toggle (`App.vue` toggles `dark` on `documentElement`); every color needs a `dark:` variant.
+
+The page renders underneath the fixed top-right control cluster (`absolute top-4 right-4 z-50`, ~120px) in `App.vue`; the editor header must avoid that corner or teleport controls into `#header-actions-portal`.
+
+### Design system anchors
+- **PilotUI** primitives: `Card, Button, IconButton, Icon, Dropdown, Tabs, Progress, Tooltip` (`pilotui/elements`); `Select, SwitchBall, TextArea, Input, CheckboxInput` (`pilotui/form`); `Modal` (`pilotui/complex`).
+- **Glassmorphism** utility classes from `main.css`: `.glass-card`, `.glass-card-hover`, `.input-focus-ring`, `.custom-scrollbar`. Floating tool clusters use the `GraphToolbar` recipe (`bg-zinc-100/80 dark:bg-zinc-900/80 backdrop-blur-md rounded-xl p-1 border shadow-lg`).
+- **Palette:** `primary #3b82f6`, `secondary #8b5cf6`, `accent #10b981`, with RGB CSS vars for glows (`shadow-[0_0_40px_rgba(var(--primary-rgb),0.2)]`).
+- **Typography:** headings `font-heading` (Outfit) `font-black tracking-tight`; body `font-sans` (Inter). The signature meta-label idiom — `text-[9px]/[10px] font-bold uppercase tracking-widest text-zinc-500` — is used verbatim for track labels, section headers, and timecodes; numbers/timecodes use `font-mono`.
+- **Radii:** panels/toolbars `rounded-2xl`/`rounded-xl`; timeline clips `rounded-lg`; hero/empty-state cards `rounded-3xl`.
+- **Icons:** the brief and the design SKILL doc say "Solar," but the **codebase actually loads and uses Tabler** (`tailwind.config.js:62` `addIconSelectors(['tabler'])`; components use `iconify tabler--…`). **Build the editor with Tabler**; flag the Solar/Tabler mismatch to whoever owns the SKILL file. (The persona data model keeps an `icon` string field; use emoji or a Tabler id there.)
+- **Motion:** `animate-fade-in-up`, `animate-pulse-soft`, hover lifts (`hover:-translate-y`), `active:scale-95`; selected segmented-control recipe: `bg-primary text-white shadow-md shadow-primary/20 ring-1 ring-primary/20` vs inactive `text-zinc-500 hover:…` (used for the Filmstrip/Context toggle). All decorative motion is gated behind `prefers-reduced-motion` (§5.11).
+
+### ASCII wireframe
+
+```
+┌──────────────────────────────────────────────────────────────────────────────────┐
+│ EditorHeader  ‹ Back   Project title            [persona ▾] cost·pill  [Undo][Redo][Export]│
+├───────────────┬────────────────────────────────────────────────┬───────────────────┤
+│ MEDIA PANEL   │             PREVIEW / PROGRAM MONITOR            │    INSPECTOR      │
+│ [+ Add media] │      ┌────────────────────────────────────┐     │  selection props: │
+│ ┌───────────┐ │      │                                    │     │  ┌──────────────┐ │
+│ │ asset A ▓▓ │ │      │        <video media://…>           │     │  │ clip / item  │ │
+│ │  ▓ proc.. │ │      │                                    │     │  │ in/out, dur  │ │
+│ ├───────────┤ │      └────────────────────────────────────┘     │  │ track, label │ │
+│ │ asset B ✓ │ │      ⏮  ⏯  ⏭   00:00:12.400 / 00:03:20.000       │  │ visual/text  │ │
+│ └───────────┘ │  ┌──────────────────────────────────────────┐   │  └──────────────┘ │
+│ CLIP TRAY     │  │ PromptBar  [persona ▾] [type an instruction…] ▷│                   │
+│ ▢▢ ▢▢ ▢▢ ▢▢  │  └──────────────────────────────────────────┘   │                   │
+├───────────────┴────────────────────────────────────────────────┴───────────────────┤
+│ TIMELINE TOOLBAR   [Zoom −/+]   [Filmstrip | Context]   [Snap]  [+Track]  [✂ Split] │
+│ ruler 00:00      00:15        00:30        00:45        01:00        01:15   ▐playhead│
+│ V1 ▐■■■■■■■▌ ▐■■■■■▌   ▐■■■■■■■■■▌            ▐■■■■▌                                    │
+│ A1 ▐~~~~~~~▌ ▐~~~~~▌   ▐~~~~~~~~~▌            ▐~~~~▌                                    │
+│ OV ▐ (overlay / "other objects" — later) ▌                                            │
+└──────────────────────────────────────────────────────────────────────────────────┘
+```
+
+### Component tree
+
+```
+VideoEditorPage.vue                 (route /editor/:id — full-bleed h-full flex flex-col)
+├─ ambient blob backgrounds (2× absolute blur)
+├─ EditorHeader.vue                 (adapt GraphHeader: back, title, cost pill, #actions)
+│    └─ Undo / Redo / Export controls
+├─ <main class="flex-1 flex min-h-0">
+│   ├─ LeftRail
+│   │   └─ MediaPanel.vue           (feature 2 — add media, per-asset preprocess status)
+│   │        ├─ AddMediaButton      (selectVideo / importMediaUrl)
+│   │        ├─ AssetRow.vue ×N     (source + BackgroundTask progress bars, error/retry)
+│   │        └─ ClipTray → ClipTile.vue ×N   (selectable, draggable; thumb + visual)
+│   ├─ CenterColumn (flex-1 flex flex-col)
+│   │   ├─ PreviewMonitor.vue       (feature 3 — <video media://…> + TransportControls)
+│   │   └─ PromptBar.vue            (feature 6/7 — PersonaPicker + BaseMessageInput REUSE)
+│   └─ RightRail
+│       └─ Inspector.vue            (selected clip/item/track properties)
+└─ TimelinePanel.vue                (features 3/4/5 — bottom, resizable, role="application")
+    ├─ TimelineToolbar.vue          (Zoom, ViewToggle Filmstrip⇄Context, Snap, +Track, Split)
+    ├─ PlayheadRuler.vue            (ticks; click/drag scrub → playheadSec)
+    ├─ <div class="tracks custom-scrollbar overflow-x-auto">
+    │    ├─ TrackLane.vue kind="video"    → TimelineClip.vue ×N
+    │    ├─ TrackLane.vue kind="audio"    → TimelineClip.vue ×N
+    │    └─ TrackLane.vue kind="overlay"  ("other objects" — later)
+    └─ Playhead.vue                 (absolute vertical line, transform: translateX)
+Modals (Teleport): PersonaEditor.vue, ExportDialog.vue, DependencyPrompt.vue
+```
+
+**Reuse callouts:** the prompt box embeds **`BaseMessageInput.vue`** (send + attachments + thinking toggle) with a persona selector added. Preprocessing progress reuses `thread.backgroundTasks` + `onBackgroundTaskUpdate` rendered like `MediaNode.vue`'s task bars. Video playback reuses the `<video :src="media://…">` pattern from `MediaNode`/`VideoNode`. Personas use `Modal` + `TextArea`/`Input`.
+
+---
+
+## 5. Feature Specifications
+
+### 5.1 Media Panel & Import  *(feature 2, part 1)*
+
+**Behavior.** The left-rail media panel lists all `MediaAsset`s imported into the project. **Add media** opens the native picker (`window.api.selectVideo()` / `window.api.showOpenDialog()`) for local files, or accepts a URL/YouTube link routed through `window.api.importMediaUrl(...)` (reusing `ytdlp.ts`; `window.api.fetchVideoFormats()` — channel `fetch-video-formats` — for resolution choice; `download-progress` for progress). On add, the file is copied to `tempDir/media/<assetId>/`, `window.api.getVideoMetadata()` probes it, a `MediaAsset` is created, and per-asset preprocessing (§5.2) starts.
+
+**States.** Empty (CTA), importing (progress bar from `download-progress`), preprocessing (per-step `BackgroundTask` bars), ready (clip tray populated), error (retry affordance — see §5.10). Each `AssetRow` shows name, thumbnail, duration, `hasAudio` badge, and a `preprocessState` rollup.
+
+**Acceptance criteria.**
+- User can add ≥1 local video and ≥1 URL video into the same project; both appear as distinct assets.
+- Per-asset metadata (duration/resolution/fps/hasAudio) displays after probe.
+- Removing an asset (`window.api.removeMediaAsset(...)`, channel `remove-media-asset`) deletes its `tempDir/media/<assetId>` artifacts and removes its clips/timeline items.
+- Multiple concurrent imports do not corrupt each other's artifact folders (per-asset namespacing).
+
+### 5.2 Per-Video Preprocessing & Auto Scene-Splitting into Selectable Pieces  *(feature 2, part 2)*
+
+**Behavior.** Each asset runs the existing preprocessing chain, re-keyed per media id. Grounded in current code:
+- **Proxy:** `toLowResolution` → 480p proxy (`ffmpeg/index.ts`), stored as `MediaAsset.proxyPath` (used for scrubbing/thumbnails; original kept for export).
+- **Audio/transcript:** `toAudio` + transcript phases (optional/opt-in for the editor — scenes+proxy+filmstrip are free local ffmpeg/scenedetect; Gemini transcript/description costs are opt-in).
+- **Scene split into pieces:** `SceneDetector.detectScenes` (`scenedetect detect-content -t 27.0`) → `Scene[] { startTime, endTime, duration }`. Each scene becomes one selectable `Clip` (feature 2's "small pieces").
+- **Thumbnails:** `extractFrame(asset, scene.startTime + duration/2)` → 480p JPG per scene (as `generateSceneDescription` already does).
+- **Context text:** per-scene Gemini one-line descriptions → `scene_descriptions.json`; `enrichTranscriptWithScenes` fuses them into `EnrichedTimelineSegment.visual` — this is the context-preview data (§5.5).
+
+**Per-asset preprocessing scope — the load-bearing refactor (M1 exit gate, not a footnote).** Today the pipeline is single-`videoPath` and `savePreprocessing` writes into the flat `Thread.preprocessing`. Features 2 and 4 depend on running that chain **per asset** without collisions. `MediaAsset.preprocessing` reuses the exact shape of `Thread['preprocessing']`, so the change is to **parameterize the writer with a target** rather than fork the phases:
+
+```ts
+// PipelineContext — before: savePreprocessing(patch: Partial<Thread['preprocessing']>)
+interface PreprocessTarget { threadId: string; assetId?: string; baseDir: string }
+savePreprocessing(patch: Partial<Thread['preprocessing']>, target: PreprocessTarget): Promise<void>
+// assetId set   → merge into that MediaAsset.preprocessing; all paths under target.baseDir = tempDir/media/{assetId}
+// assetId unset → legacy thread-level write (existing chat flow unchanged)
+
+// BackgroundTaskManager
+startPreprocessing(threadId: string, videoPath: string,
+                   opts?: { assetId?: string; baseDir?: string; steps?: PreprocessStep[] })
+// task ids namespaced: `${assetId}:downscale`, `${assetId}:scenes`, `${assetId}:descriptions`, …
+```
+
+**M1 spike gate (must pass before wiring the media UI):** confirm the extraction phases read all input/output paths from `PipelineContext`/`target.baseDir` and do **not** hard-code `thread.videoPath` / `thread.preprocessing`; if any do, lift them to the context first. Deliverable: a passing spike that preprocesses two assets into separate `tempDir/media/{assetId}` folders with no cross-writes.
+
+All steps run as **background tasks**, each idempotent, broadcasting `background-task-update`. The media panel subscribes via `window.api.getBackgroundTasks()` (channel `get-background-tasks`) + `onBackgroundTaskUpdate` (the exact pattern in `videoStore`).
+
+**States per asset:** `pending → running (per step) → completed | error`; each step independently toggleable (scenes+proxy without Gemini descriptions is a valid completed state). Partial failure is isolated per asset (§5.10).
+
+**Corrective controls.** Expose a detector **sensitivity** (threshold) control; ship **merge selected scenes** / **split further** so users cheaply correct over/under-splitting. Offer a Premiere-style three-way output as a mode: (a) cut into separate pieces (default), (b) keep one clip with scene markers, (c) collect into a bin/list.
+
+**Acceptance criteria.**
+- After preprocessing, each asset yields N selectable clips equal to its detected scenes; each clip has a thumbnail and, when descriptions ran, a `visual` string.
+- Preprocessing a second asset does not overwrite the first's `scenes.json`/frames (per-asset folders).
+- Live per-step progress appears in the media panel and updates without a page reload.
+- Detector threshold change re-runs detection and refreshes clips.
+- One asset failing (bad probe, scenedetect error) marks only that asset `error` and does not block others.
+
+### 5.3 Preview / Program Monitor  *(feature 3, part 1)*
+
+**Behavior.** A large center monitor previews the **composed timeline** at the playhead. Because there is no real-time composite engine, preview is **EDL playback in the renderer**: a single (double-buffered) HTML5 `<video>` plays the relevant clip's 480p **proxy** via `media://`, seeking to `sourceIn + (playheadSec − timelineStart)` and switching source at clip boundaries. Overlay/text tracks (later) would draw on a Canvas layer above the video. Transport controls: play/pause, seek, frame-step, current-time/total readout (`font-mono`). During playback, a `requestAnimationFrame` loop reads `video.currentTime` and advances `playheadSec`; during scrub, `playheadSec` drives `video.currentTime` one-way. **Retimed items** set `video.playbackRate = item.speed` so preview matches the exported duration. For **long timelines**, an always-visible **overview/minimap strip** and a chapter/marker jump list (§5.6) let the user navigate hours without scrubbing linearly.
+
+**States.** Empty (no items), paused-at-playhead, playing, seeking/scrubbing, buffering, boundary-switch. Uses proxy when present, falls back to original.
+
+**Acceptance criteria.**
+- Moving the playhead updates the monitor frame in **< 100 ms** at proxy resolution.
+- Playback advances the playhead smoothly and crosses clip boundaries without a visible full reload stall (double-buffer or preloaded next source).
+- A retimed item plays back at its `speed` (preview duration == export duration).
+- Time readout matches the timeline ruler position; jumping to a chapter/marker is immediate on an hours-long timeline.
+
+### 5.4 Timeline & Tracks  *(feature 3, part 2, and feature 5)*
+
+**Behavior.** A bottom, resizable timeline built as a **plain Vue 3 component tree** (not Vue Flow — see §7), driven by a single reactive `pxPerSecond`. Helpers `secToPx = s => s * pxPerSecond` and `pxToSec = p => p / pxPerSecond`. Each item positions via `transform: translateX(secToPx(timelineStart))` with `width: secToPx(duration)`.
+
+- **Tracks (feature 5):** default seed = one **video** track (order 0) + one **audio** track (order 1). Users can add **overlay/"other objects"** tracks (`kind: 'overlay' | 'text'`) whose items are inert stubs in v1. Track headers show the uppercase meta-label idiom + mute/lock/hide toggles.
+- **Drag pieces onto tracks (feature 3):** native HTML5 DnD from `ClipTile` (`draggable`, `dragstart` sets `dataTransfer` clipId); `TrackLane` handles `dragover`/`drop`, computing `atSec = pxToSec(offsetX + scrollLeft)` and creating a `TimelineItem` via `clipToItem`. A keyboard-only placement path exists (§5.11).
+- **Gap behavior:** given the cleaning/tightening workflow (long-form *and* summarization), default to a **magnetic/auto-ripple** timeline — deleting/removing a scene closes the gap; a modifier leaves a gap.
+- **Virtualization:** only clips/frames intersecting the scroll window are mounted (windowed rendering), so the timeline stays at 60fps past the budget in §8.
+
+**States.** Empty track, item selected, item dragging (intra-timeline moves use Pointer Events + `setPointerCapture`, not DnD), snapping (guide line shown), track muted/locked/hidden.
+
+**Acceptance criteria.**
+- Dropping a clip onto a track creates an item at the drop time with correct `in/out/duration`.
+- Video, audio, and overlay lanes render distinctly; overlay items are visibly marked "not yet rendered."
+- Muting an audio track excludes it from preview and export.
+- Timeline horizontal-scrolls within its own `overflow-x-auto` container; the page body never scrolls horizontally.
+
+### 5.5 Timeline View Toggle: Frames-preview vs Context-preview  *(feature 4)*
+
+**Behavior.** A single `editorStore.timelineView: 'filmstrip' | 'context'` (segmented control, using the `GraphToolbar` active-recipe classes) switches how `TimelineClip` bodies render:
+- **Filmstrip (frames-preview):** a horizontal strip of frame JPGs tiled to the clip width, sourced from a **new batched filmstrip generator** (see §7/§8 — `extractFrame` is one-process-per-frame and too slow for a dense strip). Frames lazy-load (`IntersectionObserver` / `loading="lazy"` on `<img media://…>`), only mounting clips/frames intersecting the visible window.
+- **Context-preview:** renders each clip's `visual` (the `EnrichedTimelineSegment.visual` string) plus optional transcript `text`, styled like the existing segment card in `VideoNode.vue` (mono start/end pill + italic text + "Visual Scene context" block).
+
+**States.** Filmstrip generating (skeleton), filmstrip ready, context (has description), context (no description → show timecode + "no description; run enrichment").
+
+**Acceptance criteria.**
+- Toggling updates every visible clip's body without re-fetching source video.
+- Context mode shows the same `visual` string produced by enrichment for that scene.
+- Filmstrip mode over the **visible window** (at any total clip length) uses the batched generator (single ffmpeg pass), not hundreds of processes, and completes within the per-window budget in §8.
+
+### 5.6 Manual Editing Tools  *(feature 6, manual side)*
+
+**Adjusting the timing of a section is a first-class, three-way operation** (the user's core long-form need): a selected item's on-timeline duration can be **reduced**, **extended**, or the section can be **cut**. Each maps to a concrete tool below, and all are also drivable from a numeric field in the inspector so a user can type an exact duration ("make this 8.0 s") instead of dragging.
+
+**Behavior.** Direct-manipulation tools, all mutating the timeline document (renderer-side; no per-op IPC — persisted via debounced autosave):
+- **Trim (reduce/extend by changing content):** drag either edge of a selected item (Pointer Events); adjusts `in`/`out` and `duration`. Reduces the section by showing *less* source, or extends it by revealing *more* source — bounded by `0 ≤ in < out ≤ asset.duration`. Ripple-trim (with modifier) shifts downstream items to keep them butted.
+- **Retime / Speed (reduce/extend by changing playback rate):** set a constant `speed` factor (or type a target on-timeline duration) so the *same content* plays faster or slower. Effective on-timeline `duration = (out − in) / speed`. Speed > 1 **reduces** the section (compress a slow stretch); speed < 1 **extends** it (stretch a beat out, or reach a target length when there's no more source to reveal). Rendered at export via `setpts=PTS/${speed}` (video) + chained `atempo` (audio, pitch-preserved by default); the inspector shows a small "1.5×" badge and the item is subtly hatched so retimed sections are legible on a long timeline. Ripple neighbors on change so nothing overlaps.
+- **Cut (split, then delete/ripple):** **Split (razor)** at the playhead into two items sharing the source (no media deleted; Tabler `tabler--blade-filled`, already used in `BaseMessageInput`) — each split item keeps `sourceAssetId`/`sourceClipId` but **drops any single `masterSegmentIndex`** (it now spans a sub-range that no longer maps to one master scene; see §5.7). **Delete** removes an item leaving a gap; **Ripple-delete** removes it and closes the gap (default magnetic behavior) — non-negotiable for both summarization *and* tightening a long recording.
+- **Move:** drag an item along/across tracks; snapping to other clip edges, the playhead, scene boundaries, and markers (threshold in **pixels** → seconds via `pxToSec`, so snap feel is zoom-independent; show a snap guide line).
+- **Silence / dead-air finder (assistive, long-form):** an optional per-asset pass (reuses the extracted audio; ffmpeg `silencedetect`) surfaces low-energy regions as suggested cut ranges the user reviews and applies as ripple-deletes — it never auto-commits (§2 non-goals). Big lever for podcasts/webinars.
+- **Zoom:** Ctrl/⌘+wheel adjusts `pxPerSecond` (clamp ~4–400), anchored on the cursor's time position; a **fit-to-window** and **fit-to-selection** control matter on multi-hour sequences.
+- **Markers & chapters:** time-based bookmarks on the ruler (press M); markers double as chapter points for navigating long timelines (§5.3/§8) and can seed export chapter metadata (deferred).
+
+Each committed manual change (on interaction-end / coalesced) appends a `manual`-origin history step (§6). Retime and ripple operations record their inverse so they undo cleanly.
+
+**Deferred (v2):** keyframed speed *ramps*, roll/slip/slide, 3-point edits with a separate source monitor, JKL trimming, nested sequences, transcript-word-level filler removal.
+
+**Acceptance criteria.**
+- A section's on-timeline duration can be **reduced**, **extended**, and **cut** — via trim, via retime (speed), and via split+ripple-delete respectively — by drag **or** by typing a numeric duration/speed in the inspector.
+- Retime is frame-consistent between preview and export: on-timeline `duration == round((out−in)/speed)`, audio stays in sync, and pitch is preserved unless the user opts out.
+- Split at playhead yields two independently-selectable items whose combined range equals the original.
+- Ripple-delete closes the gap by default; with the modifier, leaves a gap; ripple-trim/retime keep downstream items butted.
+- Silence finder lists candidate ranges without altering the timeline until the user applies them.
+- Snap engages within the pixel threshold at any zoom level, with a visible guide.
+- Every manual edit (incl. retime) is undoable (§6).
+
+### 5.7 Prompt Box / AI Editing  *(feature 6, prompt side)*
+
+**Behavior.** The prompt bar (embedding `BaseMessageInput`) calls `window.api.runEditorPrompt({ threadId, personaId, prompt, baseVersionId })` (channel `run-editor-prompt`). The main process reuses the existing pipeline: `intent.determineIntent` decides chat vs edit; `generateTimeline` runs in `edit` mode when a base timeline exists, else `new` mode; the **active persona's `systemPrompt` is prepended to the generator's `systemInstruction`**, and `persona.defaults.targetDurationSec` feeds `targetDuration`. Status streams over `pipeline-update`.
+
+**Addressing model — the AI operates on live item ids, not master-scene indices.** The generator must be able to mutate hand-split/hand-trimmed items that no longer map to any master scene, so the contract is item-id based, not index based:
+
+1. **Context passed to the model** = the current `items[]`, each serialized as `{ id, trackId, sourceAssetId, timelineStart, in, out, duration, speed, label, visual?, masterSegmentIndex? }`. A fresh-from-master selection carries `masterSegmentIndex`; a hand-created item carries none. The model also receives each asset's enriched master timeline separately, so it can pull in **new** material not yet on the timeline.
+   - **Context windowing (long-form, required).** A multi-hour project's `items[]` + full enriched master timelines will **exceed the model's context window**, so context is bounded, never dumped wholesale: (a) if the user has a **selection**, send only the selected items plus a small neighborhood; (b) else if the timeline exceeds a threshold (default **~40 min / ~400 items**), send the **current chapter/marker window** around the playhead plus a compact whole-timeline outline (per-chapter summaries, not every scene); (c) enriched master-timeline scenes are included **only** for assets referenced in-window, and summarized past a per-asset cap. The prompt bar shows the active scope ("Editing: Chapter 3 · 12 items") so the user knows what the AI can see, and can widen it explicitly. This keeps token cost and latency bounded regardless of total runtime (§8).
+2. **Diff returned by the model** = a `TimelineDiff` keyed to those live ids: `removeItemIds: string[]` and `updateItems: [{ id, ...partial }]` address existing items **by id**; `addItems` introduces new placements referencing a `sourceClipId` or `sourceAssetId + in/out` (optionally `masterSegmentIndex` when pulling a whole master scene).
+3. **Validation before apply:** the diff's `schemaVersion` must be known (unknown ops/versions are rejected, not partially applied); every `removeItemIds`/`updateItems.id` must exist in the base version; every add/update `in/out` must satisfy `0 ≤ in < out ≤ asset.duration` and yield `duration > 0`. When a diff sets `speed`, it is **clamped to the retime range (0.25×–4×)** and the item's on-timeline `duration` is **recomputed** as `(out−in)/speed` — the model never sets `duration` directly. Unknown ids, out-of-bounds ranges, or out-of-range speeds are rejected and surfaced, never silently applied.
+4. **AI results apply immediately as a revision** *(revised — supersedes the original ghost/accept-reject design)*. The validated diff is applied to the working timeline (with overlap repair) and lands as a **new revision** branching from the current one; the timeline switches to it so the user sees the real result — no ghost preview, no Accept/Reject step. A compact `AiResultCard` shows the persona, the assigned `V{n}`, op counts, rationale (leaning on each item's `visual`), cost, any dropped-op / thin-context / truncation notices, and a **"Back to V{parent}"** jump. "Rejecting" = switching back to the parent revision; the result stays in the tree. See §5.7a.
+5. **Manual edits feed back in.** Hand-edits mutate the working items; the **next** prompt re-serializes the current `items[]` as context, so "now make it 30 seconds" operates on the tweaked ids. Unsaved manual work is silently **auto-checkpointed** into its own revision before an AI result lands, so nothing is stranded.
+6. **Prompt scope follows selection.** With items selected, the context/diff is restricted to the selection; with nothing selected, to the whole timeline (widenable via the scope chip).
+
+**Mid-flight base change.** If the user hand-edits while a prompt runs, the returned diff is dry-run-validated against the **live** doc at completion; ids that no longer exist are dropped and surfaced on the result card. The base timeline is never corrupted.
+
+**States.** Idle, running (streamed status), applying (revision created), error. Abortable via `window.api.abortEditorPrompt()`.
+
+**Acceptance criteria.**
+- A prompt with an active persona applies immediately and creates an `ai`-origin revision keyed to current item ids.
+- The diff correctly targets a hand-split item (addressed by id, not by master index).
+- "Back to V{parent}" restores the pre-prompt state; the AI revision remains in the tree.
+- After a manual tweak, a follow-up prompt's context reflects the tweak.
+- An out-of-bounds or unknown-id diff entry is dropped (repaired), surfaced on the card; the working timeline stays valid.
+
+### 5.7a Revisions — branchable AI/manual checkpoints  *(post-v1 rework; commit `68225ae`)*
+
+Replaces the original per-diff Accept/Reject review with a **revision tree**, mirroring the chat editor's every-generation-is-a-version paradigm.
+
+- **Revision creators:** every AI result (auto) + an explicit **"Save revision"** manual checkpoint (bookmark button in the Revisions panel and timeline toolbar, optional label). Manual edits between checkpoints mutate the working state; the fine-grained undo ring still handles them (⌘Z undoes an AI diff in place right after it lands).
+- **Model:** `EditorRevision { id, parentId, seq, origin: 'init'|'ai'|'manual', label, turnId?, personaId?, snapshot: {tracks, timeline, timelineMeta, markers}, createdAt }`. Snapshots are **full and self-contained** — never diff-chained into the capped undo ring (which evicts). Persisted in a sidecar `userData/editor-revisions/{threadId}.json` (own monotonic `revisionCounter`, cap 100 with oldest-leaf-only pruning, root protected); the thread doc carries only `currentRevisionId` (autosave stays O(1)).
+- **Switching** a revision restores its snapshot (incl. markers), resets the fine-grained ring (stale redo diffs would corrupt a switched snapshot), and guards unsaved changes with a Save & switch / Discard / Cancel dialog. Blocked while a prompt runs (parentage correctness). Root ("Original") is lazily bootstrapped on first use — zero migration; losing the sidecar never mutates the working doc.
+- **Views:** a **list** (DFS tree with depth indent, `V{n}` pills, origin icons, first-clip thumbnails, current ring + dirty asterisk, hover subtree-delete) and a **graph** (standalone Vue Flow modal — main line down, branches fan right, click-to-switch with the modal staying open for branch-hopping). The right rail is tabbed **Inspect | Revisions**.
+
+### 5.8 Editor Personas  *(features 7 & 8)*
+
+**Behavior.** A persona is a named, swappable **system-prompt profile** plus a few typed defaults. Predefined personas are **read-only and cloneable** ("Duplicate to edit"); users create their own via a `Modal` form (name, icon, description, large `systemPrompt` textarea, tone, target-duration/pacing). Personas persist in a **global library** via `window.api.setPersonas(...)` / `window.api.getPersonas()` (channels `set-personas` / `get-personas`, backed by `settingsManager` — the same mechanism as `modelSettings`; `personas` is a **net-new** `settingsManager` field, see Open Q3) so they're reusable across projects; the project stores only `activePersonaId` + optional project-local `customPersonas[]`. Resolution order: `customPersonas` → global library → built-ins. A live one-line "This persona will…" preview helps non-technical users. `tone`/`defaults` are injected as **guidance, not guardrails**, and prompts are phrased positively (do-this, not don't).
+
+**Feature 8 (deferred):** each persona will later be backed by **feature-sets** (groups of effects). For v1, text is enough — `featureSets` ships as a stubbed `FeatureSetRef[]` (always `[]`), so v2's effect-group work is an additive schema change, not a migration.
+
+**A `targetDurationSec` of `null` means "no length target — editorial cleanup that preserves the full runtime."** This is what makes a persona a *long-form* editor rather than a summarizer: it tightens, retimes, reorders, and chapters without a shrink goal. The predefined set covers both modes.
+
+**Predefined personas — long-form / editorial (keep most of the runtime):**
+
+| id | name | icon | tone | defaults | systemPrompt gist |
+|---|---|---|---|---|---|
+| `podcast-editor` | Podcast Editor | 🎙️ | neutral | null, relaxed | Keep the full conversation; remove dead air, long silences, and false starts; tighten rambling stretches (suggest retime, not deletion, where content matters); preserve every distinct point and speaker turn; never cut for length alone. |
+| `longform-polish` | Long-Form Polisher | 🎬 | warm | null, balanced | For vlogs/webinars/streams: remove setup fumbles and dead time, smooth pacing, keep the whole narrative and all substantive content; reorder only when it clearly improves flow. |
+| `silence-cleaner` | Silence & Filler Cleaner | 🧹 | neutral | null, tight | Aggressively remove silence, dead air, and empty gaps; leave all spoken/substantive content intact; propose ripple-deletes over the low-energy regions; do not shorten meaningful segments. |
+| `chapter-organizer` | Chapter Organizer | 🗂️ | authoritative | null, relaxed | Keep full length; segment the piece into logical chapters, place markers at topic boundaries, and label each; reorder segments only if explicitly asked. |
+| `study-notes` | Lecture Study-Notes | 🎓 | authoritative | null, relaxed | Retain every scene with distinct instructional content; drop only silence/repetition/asides; prioritize completeness; preserve chronological order. |
+
+**Predefined personas — summarization / short-form (shrink to a target):**
+
+| id | name | icon | tone | defaults | systemPrompt gist |
+|---|---|---|---|---|---|
+| `concise-summarizer` | Concise Summarizer | ✂️ | neutral | 60s, tight | Cut to the essential information; keep only scenes that advance the core message; drop redundancy and dead air; prefer the shortest coherent edit. |
+| `highlight-reel` | Highlight Reel | ⚡ | energetic | 30s, tight | Select the most visually striking, high-energy scenes; favor peaks/reactions/motion; fast pacing, strong opening and closing beats. |
+| `storyteller` | Storyteller | 📖 | warm | 180s, balanced | Assemble a narrative arc (setup, development, payoff); preserve context and emotional throughline; keep transitions logical. |
+| `social-shorts` | Social / Vertical Shorts | 📱 | playful | 45s, tight | Produce a vertical-friendly short; hook in the first 3 seconds; one clear idea; rapid cuts; end on a strong beat. |
+
+Personas are grouped by mode in the picker (Long-form vs Summarize); the default for a new editor project is **`podcast-editor`** (length-preserving), reflecting the primary audience. A user cloning any built-in gets an editable copy in the same group.
+
+**Persona data fields:** `id, name, icon, description, systemPrompt, builtin`, `defaults { targetDurationSec?, aspectRatio?, pacing? }` (a `null`/absent `targetDurationSec` = length-preserving editorial mode), optional `mode?: 'longform' | 'summarize'` for grouping, stub `featureSets?` (see §6).
+
+**Acceptance criteria.**
+- The predefined personas (long-form + summarize groups) appear grouped by mode, are read-only, and can be cloned into editable copies; a new project defaults to `podcast-editor`.
+- A user-created persona persists globally and is selectable in a new project.
+- Switching the active persona changes the system prompt injected into `run-editor-prompt`.
+- Deleting a built-in is disallowed; deleting a user persona works.
+
+### 5.9 Export / Render
+
+**Behavior.** `window.api.exportEditorTimeline({ threadId, versionId })` resolves the current snapshot's items against their assets (`originalPath` for final render, `proxyPath` for fast preview renders). Two paths:
+- **Fast path (day one):** when the sequence is one video track over one source, **every item is `speed === 1.0`** (no retime), and no overlay/text items — the common "AI made a highlight reel" case — map items → `TimelineSegment[]` and call the existing **`assembleVideo`** unchanged. Any retimed item disqualifies the fast path (assembleVideo has no `setpts`), routing to the multi-source path.
+- **Multi-source path (new):** `assembleTimeline(snapshot, assets, …)` builds an N-input FFmpeg graph using **segment-then-concat (option C)**: slice the sequence at every clip boundary into regions, render each region with a bounded per-region filtergraph normalized to project width/height/fps, then stitch regions with the concat demuxer (`-c copy` when intermediates share a concat-copyable codec). Reuse the per-platform encoder selection from `toLowResolution`/`assembleVideo` (videotoolbox on Mac, vp9 for webm, x264 elsewhere). Progress via `render-progress`; abortable via `AbortSignal`.
+- **Retime in render (per item):** for an item with `speed ≠ 1`, its video segment gets `setpts=PTS/${speed}` and its audio gets a chained `atempo` factor of `speed` (chain multiple `atempo` stages so each stays within ffmpeg's 0.5–2.0 range, e.g. `speed=4 → atempo=2,atempo=2`). With `preservePitch=false`, use `asetrate` instead so pitch shifts with speed. The item's source cut is `(out−in)` of real source; after retime it occupies exactly `(out−in)/speed` on the region timeline, matching the on-timeline `duration`. This is why retime routes through `assembleTimeline`, not the fast path.
+
+**Per-region audio graph — P1 boundary decided (mixed output).** Audio is the part most likely to desync in segment-then-concat, so v1 fixes an explicit graph rather than leaving it an open question:
+- **P1 scope:** any number of audio *sources* per region, mixed to **one stereo output** (no routing to separate output stems). This satisfies the "≥2 sources, synced audio" and "muting excludes a track" acceptance criteria without a full mixer.
+- **Per region R covering `[t0, t1)`:** collect the set of *unmuted* timeline items (across all tracks) whose audio is active in R. Each contributing stream is `atrim`/`asetpts`-cut to R, `aresample=48000` + channel-normalized to stereo, and `volume`-scaled by its item `gain` (default 1.0); the set is combined with `amix=inputs=k:normalize=0` (explicit `volume` avoids amix's auto-attenuation). A region with **no** active audio emits `anullsrc` of exactly `t1−t0`; a partial-coverage region is `apad`-ded to the full region length. Every region's audio is exactly region-length, so video and audio stay frame-aligned across the concat.
+- **Muting:** a `Track.muted` (or item `muted`) removes that stream from the region's input set; if that empties the set, the region falls back to `anullsrc`.
+- **Gaps / offsets:** a gap on the timeline is a region with no active stream → `anullsrc` silence of the gap length.
+- **Sync guarantee:** because a region's video and its mixed audio are re-encoded to the identical duration and normalized rate before concat, boundaries preserve A/V sync; the concat demuxer only stitches equal-length A+V region pairs.
+
+**Overlay/text tracks in export.** v1 **ignores** overlay/text-track items entirely (they are inert). When such tracks are non-empty, `ExportDialog` shows a one-line notice ("Overlay/text tracks won't appear in this export") so users aren't surprised by missing content.
+
+**The render gap (explicit).** `assembleVideo` is **single-source** trim+concat via one `complexFilter` — no second input, overlay, mixing, transition, gap, or track offset (`ffmpeg/index.ts`). Multi-source/multi-track compositing is the largest new backend lift. v1 targets **P0/P1** (single video track over single source **with no retime/overlay** via the fast path; multi-clip/multi-source concat + mixed audio + per-item retime via `assembleTimeline`); overlay/text/effects compositing is P2 (§9 M5).
+
+**Acceptance criteria.**
+- A single-source highlight-reel timeline exports via `assembleVideo` and matches the previewed cut.
+- A multi-clip timeline drawing from ≥2 sources exports a correct concatenation with **synced** audio.
+- Muting an audio track excludes its stream from the exported mix.
+- A timeline with a gap produces the correct duration of silence at that region.
+- Export is abortable and reports progress; a non-empty overlay/text track triggers the export-dialog notice.
+- `save-video` writes the final file to a user-chosen location.
+
+### 5.10 Empty, Error & Dependency States
+
+The single-video chat flow tolerates most failures because it fans out to one asset; the editor fans out to N assets, so partial-failure handling is first-class.
+
+- **Missing scenedetect/ffmpeg dependency.** Before the first scene split, check `window.api.getDependencyStatus()` (channel `get-dependency-status`). If missing, block scene split and surface the app's existing install flow via `DependencyPrompt` → `window.api.installDependency(...)` (channel `install-dependency`, progress on `dependency-update`). Proxy/import can still proceed; scene-dependent UI shows an "install scene detection to split clips" state.
+- **ffprobe/metadata failure on import** (unsupported/corrupt file): mark the asset `preprocessState: 'error'` with the ffprobe message and a **Retry** action; other assets are unaffected.
+- **Per-asset partial-failure isolation:** a failure in one asset's proxy/scenes/description chain marks only that asset's tasks `error`; sibling assets keep running. The media panel shows per-asset error rows with retry.
+- **Aborted / failed URL download:** on abort or error, delete the partial `tempDir/media/{assetId}` folder and remove the half-created `MediaAsset`, so retry starts clean.
+- **Gemini quota/error during `run-editor-prompt`:** the base version stays intact (no partial commit); the prompt turn is marked `error` with the message and a **Retry** action; the proposal, if any, is discarded.
+
+**Acceptance criteria.**
+- With scenedetect uninstalled, the editor surfaces the install flow instead of failing silently, and import/proxy still work.
+- A corrupt import marks only that asset errored, with retry.
+- A failed Gemini prompt leaves the accepted timeline unchanged and offers retry.
+- Cancelling a URL import removes its temp folder.
+
+### 5.11 Keyboard Shortcuts & Accessibility
+
+**Scope & conflict handling.** Editor shortcuts are active only while focus is inside `VideoEditorPage` and **not** inside a text field (prompt box, persona editor). They do not shadow the existing app/global bindings; the timeline panel is `role="application"` so its keys don't collide with browser/AT navigation. `Ctrl/⌘+Z` / `Ctrl/⌘+Shift+Z` map to editor undo/redo only when the editor owns focus.
+
+| Key | Action |
+|---|---|
+| `Space` | Play / pause |
+| `←` / `→` | Step 1 frame back / forward |
+| `Shift+←` / `Shift+→` | Nudge selected item 1 frame (hold `Alt` = 1s) |
+| `Home` / `End` | Playhead to start / end |
+| `I` / `O` | Set in / out on the selected item |
+| `S` or `B` | Split (razor) at playhead |
+| `Delete` / `Backspace` | Ripple-delete (hold `Alt` = lift, leave gap) |
+| `M` | Add marker at playhead |
+| `Ctrl/⌘ + wheel` or `+` / `-` | Zoom timeline (cursor-anchored) |
+| `Ctrl/⌘+Z` / `Ctrl/⌘+Shift+Z` | Undo / redo |
+| `Tab` / `Shift+Tab` | Move focus across the four panels |
+| `Enter` on a focused ClipTile | Place clip on the active track at the playhead (keyboard alternative to drag) |
+| `Esc` | Clear selection / dismiss proposal |
+
+**Accessibility.**
+- **Focus order:** Header → Media panel → Monitor+transport → Prompt bar → Inspector → Timeline, with a visible focus ring (`input-focus-ring`) on every interactive element.
+- **ARIA for the time canvas:** the timeline is `role="application"` with an `aria-label`; each `TrackLane` is a labelled group (`role="group"`, `aria-label="Video track 1"`); each `TimelineClip` is `role="option"`/`aria-selected` exposing `aria-label` = `"<label>, <start>–<end>, <duration>"`; the playhead exposes current time via `aria-valuetext` and screen-reader-live announcements on seek / boundary crossing.
+- **Keyboard-only editing:** clip placement (`Enter`), trim (`I`/`O`), nudge (`Shift+arrows`), split, and ripple-delete are all reachable without a pointer, so drag is an enhancement, not a requirement.
+- **Reduced motion:** all `animate-*`/`pulse-soft`/hover-lift decoration is wrapped in `@media (prefers-reduced-motion: reduce)` to disable non-essential animation; playback and the playhead still move.
+
+**Acceptance criteria.**
+- Every manual edit in §5.6 is achievable by keyboard alone.
+- The timeline exposes ARIA roles/labels for tracks, clips, and playhead, and announces the current time on seek.
+- Editor shortcuts do not fire while typing in the prompt/persona fields and do not shadow existing global bindings.
+- With `prefers-reduced-motion`, decorative animation is suppressed.
+
+---
+
+## 6. Data Model
+
+All new types go in `src/shared/types.ts` (imported by main + renderer). **Canonical time unit inside the editor is seconds (number)**; SRT strings (`HH:MM:SS,mmm`) appear only at the boundary with legacy `generateTimeline`/`assembleVideo`, via `srtToSeconds`/`secondsToSrt` helpers.
+
+### Coexistence with `Thread` — extend, don't fork
+Editor projects are `Thread` records discriminated by `type: 'editor'`, persisted by the unchanged `ThreadManager` (atomic update queue, mirror-to-tempDir, recovery, path-repair, `thread-updated` broadcast). They appear on the Home grid alongside chat/image threads. Because `Thread.preprocessing` and `Thread.messages` are **required** in `types.ts`, an editor thread still initializes `preprocessing: {}` and `messages: []`; only `videoPath` (genuinely optional) stays `undefined`. All editor state lives in `editor?: EditorDocument`. No migration — `editor` is optional and absent on legacy threads; existing `video`/`image` code never reads it. Before M0 exit, audit chat-only `ThreadManager` consumers (`getBranchContext`, recovery, path-repair, `thread-updated` broadcast) so editor threads with empty `messages[]` / absent `videoPath` are gated out of chat-only code (§11 Q1, §9 M0).
+
+```ts
+// src/shared/types.ts — additive
+export type ThreadType = 'video' | 'image' | 'editor'
+
+export interface Thread {
+  id: string
+  title: string
+  type?: ThreadType
+  // ...all existing fields unchanged; editor threads init preprocessing:{} and messages:[]...
+  /** Present only when type === 'editor'. */
+  editor?: EditorDocument
+}
+```
+
+### EditorDocument (per-project root)
+
+```ts
+export interface EditorDocument {
+  schemaVersion: 1
+  media: MediaAsset[]         // imported sources
+  tracks: Track[]             // lane definitions
+  timeline: TimelineItem[]    // placements across tracks — the live EDL
+  timelineMeta: TimelineMeta  // fps/resolution/duration for the sequence
+  activePersonaId: string
+  customPersonas?: EditorPersona[]  // project-local personas
+  turns: PromptTurn[]         // lightweight prompt-request log (no snapshots)
+  historyRef: EditorHistoryRef      // pointer into the sidecar history file (see below)
+  selection?: { clipIds?: string[]; itemIds?: string[] }
+}
+
+export interface TimelineMeta {
+  fps: number
+  width: number
+  height: number
+  duration: number            // seconds; derived = max(item.timelineStart + item.duration)
+  aspectRatio?: string        // "16:9" | "9:16" — persona default can set this
+}
+```
+
+### MediaAsset (imported source) + Clip (selectable "piece")
+
+```ts
+export type MediaKind = 'video' | 'image' | 'audio'
+
+export interface MediaAsset {
+  id: string
+  kind: MediaKind
+  name: string
+  originalPath: string        // absolute; served via media://
+  proxyPath?: string          // 480p proxy === today's lowResVideoPath
+  metadata?: VideoMetadata    // reuse existing VideoMetadata; duration in seconds
+  /** Reuses the EXACT shape of Thread['preprocessing'] so existing phases run per-asset. */
+  preprocessing: Thread['preprocessing']
+  preprocessTasks?: Record<string, BackgroundTask>  // reuse BackgroundTask
+  preprocessState?: 'pending' | 'running' | 'completed' | 'error'
+  preprocessError?: string
+  clips: Clip[]               // derived from scene detection
+  filmstrip?: FilmstripEntry[]
+  createdAt: number
+}
+
+export interface FilmstripEntry { time: number; thumbnailPath: string } // served via media://
+
+export interface Clip {        // a selectable scene piece (feature 2)
+  id: string
+  sourceAssetId: string
+  index: number               // 1-based, mirrors Scene/EnrichedTimelineSegment ordering
+  in: number                  // seconds into source (was Scene.startTime)
+  out: number                 // seconds into source (was Scene.endTime)
+  duration: number            // out - in
+  thumbnailPath?: string      // === scene-description framePath
+  visual?: string             // === EnrichedTimelineSegment.visual — CONTEXT-PREVIEW text (feature 4)
+  text?: string               // transcript excerpt overlapping [in,out]
+  selected: boolean           // media-panel multi-select (feature 2)
+  masterSegmentIndex?: number // back-reference into the enriched master timeline
+}
+```
+
+### Track + TimelineItem (placement)
+
+```ts
+export type TrackKind = 'video' | 'audio' | 'overlay' | 'text'
+
+export interface Track {
+  id: string
+  kind: TrackKind             // 'overlay' | 'text' = feature 5 "other objects for later"
+  name: string
+  order: number               // stacking order (0 = bottom video)
+  muted: boolean
+  locked: boolean
+  hidden: boolean
+  height: number              // px in the timeline UI
+}
+
+export interface TimelineItem {  // an instance of a clip placed on a track
+  id: string
+  trackId: string
+  sourceAssetId: string
+  sourceClipId?: string       // set when dragged from a detected Clip
+  masterSegmentIndex?: number // present only for a whole, un-split master scene; cleared on split/trim
+  timelineStart: number       // seconds on the sequence timeline
+  in: number                  // seconds into source (trim start)
+  out: number                 // seconds into source (trim end)
+  speed: number               // constant playback rate (default 1.0). >1 faster/shorter, <1 slower/longer. Retime tool (§5.6)
+  preservePitch: boolean      // default true — audio retimed with atempo keeps pitch
+  duration: number            // ON-TIMELINE duration = (out - in) / speed
+  label?: string              // defaults to Clip.visual snippet
+  gain?: number               // audio gain multiplier (default 1.0) — used by the export mix
+  muted?: boolean
+  // ---- Stubs (feature 8, later) ----
+  transform?: TimelineItemTransform
+  effects?: EffectRef[]
+  transition?: { in?: TransitionRef; out?: TransitionRef }
+  text?: TextOverlaySpec
+}
+
+export interface TimelineItemTransform { x?: number; y?: number; scale?: number; rotation?: number }
+export interface EffectRef { id: string; kind: string; params?: Record<string, unknown> } // stub
+export interface TransitionRef { kind: string; duration: number }                          // stub
+export interface TextOverlaySpec { content: string; style?: Record<string, unknown> }       // stub
+```
+
+### EditorPersona (features 7 & 8)
+
+```ts
+export interface EditorPersona {
+  id: string
+  name: string
+  icon: string                // emoji or Tabler icon id (design system uses Tabler — see §4)
+  description: string
+  systemPrompt: string        // the whole backing today (feature 7)
+  builtin: boolean            // seeded personas can't be deleted, only cloned
+  tone?: string               // persona voice shown in the picker (e.g. neutral, warm, energetic) — injected as guidance
+  mode?: 'longform' | 'summarize'  // picker grouping; longform => length-preserving editorial
+  defaults?: { targetDurationSec?: number | null; aspectRatio?: string; pacing?: 'tight' | 'balanced' | 'relaxed' } // null/absent target = preserve full length
+  featureSets?: FeatureSetRef[]  // feature 8 — LATER; typed stub, always [] in v1
+}
+
+export interface FeatureSetRef { id: string; name: string } // stub
+```
+
+### History — bounded deltas in a sidecar file (not inside the thread JSON)
+
+Undo/redo must **not** grow the atomically-rewritten `threads/{id}.json`. If a full snapshot were appended per edit into the same file the debounced autosave rewrites, a long session is O(edits²) I/O and unbounded disk. Instead, history lives in a **separate sidecar file** `userData/editor-history/{threadId}.json`, so the frequent autosave of the live document is decoupled from history growth. History is stored as **forward/inverse deltas** (`TimelineDiff` patches) with sparse keyframe snapshots, and is **hard-capped**.
+
+```ts
+export interface EditorHistoryRef {
+  currentStepId: string       // undo/redo pointer (persisted → undo survives restart)
+  stepCount: number           // for the Undo/Redo UI; the full log lives in the sidecar
+}
+
+// ---- sidecar file: userData/editor-history/{threadId}.json ----
+export interface EditorHistoryFile {
+  threadId: string
+  steps: EditorHistoryStep[]     // ring buffer, MAX_STEPS = 50
+  keyframes: TimelineSnapshot[]  // sparse; one every K = 10 steps, to bound replay cost
+  currentStepId: string
+}
+
+export interface EditorHistoryStep {
+  id: string
+  seq: number                 // monotonic (sourced like Thread.versionCounter via getNextVersion)
+  origin: 'init' | 'ai' | 'manual'
+  label?: string
+  forward: TimelineDiff       // apply to go newer
+  inverse: TimelineDiff       // apply to undo
+  turnId?: string             // set when origin === 'ai'
+  createdAt: number
+}
+
+export interface TimelineSnapshot { tracks: Track[]; timeline: TimelineItem[]; timelineMeta: TimelineMeta }
+
+export interface PromptTurn {
+  id: string; personaId: string; prompt: string
+  baseStepId: string; resultStepId?: string
+  status: 'pending' | 'running' | 'completed' | 'error'
+  error?: string; diff?: TimelineDiff
+  usage?: Usage; cost?: number; createdAt: number
+}
+
+export type TimelineDiff = {
+  schemaVersion: number                                   // validators reject unknown ops/versions (§7 forward-safety)
+  addItems?: TimelineItem[]
+  removeItemIds?: string[]
+  updateItems?: Array<{ id: string } & Partial<TimelineItem>>  // may set `speed`; duration is recomputed & clamped on apply (§5.7)
+  addTracks?: Track[]
+  removeTrackIds?: string[]
+}
+```
+
+**History policy (concrete).**
+- **Cap:** retain the most recent `MAX_STEPS = 50` steps as a ring buffer; evicting the oldest step collapses its state into the nearest older keyframe so state stays reconstructable.
+- **Coalescing:** rapid same-kind manual edits (e.g. a continuous trim drag) coalesce into one step on interaction-end / after a 400 ms idle, so a drag is one undo, not hundreds.
+- **Reconstruction cost:** redo/undo replays deltas from the nearest keyframe (≤ K = 10 steps), bounding work to O(K), not O(history).
+- **Restart:** the sidecar persists `currentStepId`, so undo/redo survives app restart up to the cap; deleting the project deletes the sidecar.
+- **AI accept** commits exactly one step (`forward` = accepted diff, `inverse` = its reverse), so one undo reverts a whole proposal.
+
+### Serialization & the seconds↔SRT bridge
+The persisted, main-consumable document **is** `EditorDocument.timeline` + `tracks` + `timelineMeta`, inside `Thread.editor` in `threads/{id}.json`; history is the sidecar above. Mapping helpers:
+
+```ts
+function segmentToClip(seg: EnrichedTimelineSegment, assetId: string, framePath?: string): Clip {
+  return {
+    id: uuid(), sourceAssetId: assetId, index: seg.index,
+    in: srtToSeconds(seg.start), out: srtToSeconds(seg.end), duration: seg.duration,
+    thumbnailPath: framePath, visual: seg.visual, text: seg.text,
+    selected: false, masterSegmentIndex: seg.index,
+  }
+}
+
+function clipToItem(clip: Clip, trackId: string, timelineStart: number): TimelineItem {
+  return {
+    id: uuid(), trackId, sourceAssetId: clip.sourceAssetId, sourceClipId: clip.id,
+    masterSegmentIndex: clip.masterSegmentIndex,
+    timelineStart, in: clip.in, out: clip.out,
+    speed: 1.0, preservePitch: true, duration: clip.duration, // speed 1.0 keeps the export fast path (§5.9)
+    label: clip.visual?.slice(0, 40),
+  }
+}
+
+// AI selection (EnrichedTimelineSegment[]) laid onto the video track as consecutive items
+function timelineToItems(segments: EnrichedTimelineSegment[], assetId: string, videoTrackId: string): TimelineItem[] {
+  let cursor = 0
+  return segments.map(seg => {
+    const item: TimelineItem = {
+      id: uuid(), trackId: videoTrackId, sourceAssetId: assetId, masterSegmentIndex: seg.index,
+      timelineStart: cursor, in: srtToSeconds(seg.start), out: srtToSeconds(seg.end),
+      speed: 1.0, preservePitch: true, duration: seg.duration, label: seg.visual?.slice(0, 40),
+    }
+    cursor += seg.duration
+    return item
+  })
+}
+```
+
+---
+
+## 7. Architecture & Integration
+
+### Renderer
+- **Route:** add `{ path: '/editor/:id', name: 'editor', component: VideoEditorPage }` to `router.ts`. Behind the existing global API-key guard; no extra guard code.
+- **Home entry:** add a third `NewThreadCard` ("Video Editor") to `HomePage.vue`; the open handler routes by discriminator: `router.push(t.type === 'editor' ? '/editor/'+t.id : '/chat/'+t.id)`.
+- **`editorStore`** (new, setup-store style matching all existing stores): holds `threadId`, `assets`, `tracks`, `items`, view state (`pxPerSecond`, `playheadSec`, `isPlaying`, `selection`, `timelineView`), `personas`, `activePersonaId`; derived `activeAsset`, `selectedItem`, `tracksByKind`; actions mirror `videoStore`'s "call api, patch local" style (`loadProject`, `addAsset`, `addItemToTrack`, `moveItem`/`trimItem`/`removeItem`, `runPrompt`, `persistProject`). Live IPC listeners (`onBackgroundTaskUpdate`, `onThreadUpdated`, `onPipelineUpdate`, `onDownloadProgress`) registered once at construction, exactly like `videoStore`. Keep derived view models (visible-clip window, filmstrip layout) in a composable (mirroring `useGraphLayout`), not in the store. Undo/redo goes through `editorStore` → history-sidecar IPC, decoupled from the debounced document autosave.
+- **Timeline is purpose-built, not Vue Flow.** Vue Flow's value (arbitrary 2-D placement + edges + canvas zoom) is unused and actively fights a 1-D time axis. Build plain `div`s positioned by `transform: translateX`/`width` off one `pxPerSecond` ref, with native Pointer Events for intra-timeline drag and HTML5 DnD for cross-panel drops. Virtualize by the scroll window. Keep Vue Flow exclusively for the existing graph editor.
+
+### Main process
+- **Editor-aware create:** `create-editor-project` → `ThreadManager.createThread` variant setting `type: 'editor'`, `preprocessing: {}`, `messages: []`, and an empty `EditorDocument`.
+- **Per-asset preprocessing scope:** as designed in §5.2 — parameterize `savePreprocessing`/`startPreprocessing` with a `{ assetId, baseDir }` target, namespace task ids, write under `tempDir/media/{assetId}/`. Contained to `tasks/index.ts` + `pipeline/index.ts`; the single-source chat flow is untouched. Gated by the M1 spike.
+- **Batched filmstrip generator (new):** `extractFrame` spawns one ffmpeg process per frame — prohibitive for dense strips. Add a single-pass batch extractor (`-vf fps=N,scale=-2:120` writing `%05d.jpg`, or a `tile=` sprite), run inside the background-task model, cached in `frames/`, generated lazily per visible region.
+- **Render engine (new):** `assembleTimeline(snapshot, assets, outputDir, opts)` — segment-then-concat (option C) with the per-region audio graph of §5.9, applying **per-item `speed`** via `setpts` (video) + chained `atempo` (audio, or `asetrate` when `preservePitch=false`). Keep `assembleVideo` as the single-source, speed-1.0 fast path. Reuse platform encoder selection and `AbortSignal` plumbing.
+- **Background-task concurrency:** verify whether `backgroundTaskManager` queues/caps today; it currently appears to start tasks immediately. If it does not cap, add a bounded queue (concurrency `K`, see §8) as **M1 work**, since the editor fans out to N assets × multiple ffmpeg/scenedetect chains.
+- **Persona library:** built-ins seeded in `src/main/constants/personas.ts`; user personas persisted via `settingsManager` under a new `personas` field (Open Q3), exposed as `get-personas`/`set-personas`.
+- **History sidecar:** read/write `userData/editor-history/{threadId}.json` via `get-editor-history` / `push-editor-step` / `set-editor-history-pointer`, independent of thread autosave.
+
+### Modularity & Extensibility
+
+The editor is built so the deferred work (effects, transitions, feature-sets, new track kinds, extra tools) plugs in **without touching core**, and so nothing here disturbs the existing chat/graph editor.
+
+- **Module boundary.** All new renderer code lives under `src/renderer/src/editor/**` (page, `editorStore`, components, composables); all new main-process code under `src/main/editor/**` (render engine, per-asset preprocessing adapter, persona store, history sidecar). Shared reuse (ffmpeg helpers, `SceneDetector`, pipeline phases, `ThreadManager`, `settingsManager`) is consumed through their existing exports — parameterized (e.g. `{assetId, baseDir}`), never forked. The two editors share only `@shared/types` and the reused main services; `Thread.type` is the single discriminator.
+- **Registries (the seam for v2).** Four small in-code registries decouple "what exists" from "what's wired," so adding an item is a data change, not a surgery:
+  - **Persona registry** — built-ins seeded in `src/main/constants/personas.ts`, merged with the user library from `settingsManager`; resolution order `project.customPersonas → global → built-ins`. Adding a persona = appending a record.
+  - **Track-kind registry** — `{ kind, label, icon, accepts(itemKind), renderInExport }`. `video`/`audio` are active; `overlay`/`text` are registered but `renderInExport:false` in v1. Adding a lane type later = one registry entry + a render handler.
+  - **Effect / feature-set registry (stub)** — `EffectRef`/`FeatureSetRef` resolve against a registry that is **empty in v1**; the render engine and persona binding already loop over it (a no-op today), so v2 effect groups attach by registering handlers, not by rewriting the pipeline.
+  - **Tool registry** — manual tools (trim, split, retime, ripple, silence-finder, marker) register as `{ id, icon, shortcut, run(ctx) }`, which also feeds the shortcut map (§5.11) and the toolbar; new tools drop in without editing the timeline component.
+- **Render engine is handler-based.** `assembleTimeline` walks regions and, per item, applies an ordered list of node builders (trim → speed → [future: transform/effects/transition] → mix). v1 ships the trim + speed builders; the transform/effect/transition builders are registered no-ops. This is why per-clip **speed** could be added in v1 without an architecture change, and why v2 effects are additive.
+- **AI diff is schema-versioned.** `TimelineDiff` carries a `schemaVersion`; validators reject unknown ops/versions rather than mis-apply them, so adding future ops (e.g. `addEffect`, `addTransition`) is forward-safe. (Retime needs no new op — the model sets `speed` inside `updateItems`, validated per §5.7.)
+
+### New `window.api` channels (renderer wrapper → IPC channel)
+
+| Wrapper (renderer) | IPC channel | Purpose | Events / notes |
+|---|---|---|---|
+| `createEditorProject(title)` | `create-editor-project` | New `Thread{type:'editor'}` + empty `EditorDocument` | reuses `ThreadManager` |
+| `addMediaAsset({threadId,filePath})` | `add-media-asset` | Copy source, probe, push `MediaAsset`, start per-asset preprocessing | `background-task-update` |
+| `importMediaUrl({threadId,url,resolution?})` | `import-media-url` | URL/YouTube import | wraps `download-video`, `download-progress` |
+| `removeMediaAsset({threadId,assetId})` | `remove-media-asset` | Delete asset + artifacts + dependent items | — |
+| `preprocessMedia({threadId,assetId,steps?})` | `preprocess-media` | Run/re-run proxy + scenes (+ optional descriptions) | `background-task-update` |
+| `getMediaScenes({threadId,assetId})` | `get-media-scenes` | `Scene[]` + per-scene thumb/visual for the tray | — |
+| `generateFilmstrip({threadId,assetId,interval})` | `generate-filmstrip` | Batch thumbnails | `render-progress` / task model |
+| `saveEditorDoc({threadId,editor})` | `save-editor-doc` | Debounced autosave of the live document | `updateThread` → `thread-updated` |
+| `getEditorHistory` / `pushEditorStep` / `setEditorHistoryPointer` | `get-editor-history` / `push-editor-step` / `set-editor-history-pointer` | Sidecar undo/redo | decoupled from doc autosave |
+| `runEditorPrompt({threadId,personaId,prompt,baseVersionId})` | `run-editor-prompt` | AI edit → `PromptTurn`/`TimelineDiff` | streams `pipeline-update` |
+| `exportEditorTimeline({threadId,versionId})` | `export-editor-timeline` | Render via `assembleTimeline`/`assembleVideo` | `render-progress`; `abort-editor-render` |
+| `getPersonas` / `setPersonas` | `get-personas` / `set-personas` | Global persona library | via `settingsManager` |
+
+Reused as-is (wrapper → channel): `selectVideo` → `select-video`, `showOpenDialog` → `show-open-dialog`, `getVideoMetadata` → `get-video-metadata`, `fetchVideoFormats` → `fetch-video-formats`, `downloadVideo` → `download-video`, `saveVideo` → `save-video`, `abortPipeline` → `abort-pipeline`, `getBackgroundTasks` → `get-background-tasks`, `getDependencyStatus` → `get-dependency-status`, `installDependency` → `install-dependency`, the `media://` protocol, and the existing event subscriptions (`onPipelineUpdate`, `onBackgroundTaskUpdate`, `onThreadUpdated`, `onDownloadProgress`, `dependency-update`).
+
+### FFmpeg multi-source render plan — options & tradeoffs
+
+| Strategy | Pros | Cons | Verdict |
+|---|---|---|---|
+| **A. One monolithic filtergraph** (all inputs, per-clip trim/overlay/amix/xfade in one pass) | Single pass, frame-accurate, correct composite, keeps HW-accel | Graph explodes with clip count; hits ffmpeg limits; long CPU/memory; one bad node fails all; poor progress granularity | Fallback only |
+| **B. concat demuxer** (`-c copy`) | Near-instant, no re-encode | Sequential single-track only; no overlay/mix/transition/offset | Trivial single-track cut (≈ today) |
+| **C. Segment-then-concat (recommended)** | Bounded per-region complexity, parallelizable, resumable, per-region progress, isolates failures, reuses HW-accel; per-region audio mix keeps A/V sync | Double-encode (mitigate: near-lossless concat-copyable intermediates); extra disk I/O; boundary-spanning transitions need overlap | **v1 target for multi-source** |
+
+Recommendation: **C**, with the existing `assembleVideo` as the degenerate fast path. Phase: P0 single-track/single-source (fast path); P1 multi-clip/multi-source concat + mixed audio (§5.9); P2 overlay/text/effects.
+
+---
+
+## 8. Technical Risks & Mitigations
+
+| Risk | Impact | Mitigation |
+|---|---|---|
+| **Multi-track/multi-source FFmpeg compositing does not exist** (`assembleVideo` is single-source) | Largest lift; blocks true NLE export | Phase it: reuse `assembleVideo` fast path day one; build `assembleTimeline` via segment-then-concat (option C) with the §5.9 per-region audio graph; overlay/effects deferred to P2 |
+| **Real-time preview of a composed multi-track timeline** | No composite engine; per-frame ffmpeg too slow | Renderer EDL playback on 480p proxies via `media://`, switching at boundaries; overlays on a Canvas layer; ffmpeg composite reserved for export. **Budget: scrub-to-frame < 100 ms at proxy res** |
+| **Filmstrip/thumbnail cost for long videos** | `extractFrame` = one process/frame → CPU thrash | Batched single-pass extractor; lazy per visible region; cache in `frames/`; run in background-task model. Density is **zoom-adaptive** (fewer frames when zoomed out) so a 3-hour timeline never materializes more strip frames than a short one. **Budget: filmstrip for a visible window renders ≤ 8 s regardless of total length; on-screen strip ≤ ~1 frame / 24 px** |
+| **AI context exceeds the model window on long projects** | A multi-hour `items[]` + full master timelines won't fit; requests fail or truncate silently | **Context windowing (§5.7):** send selection/chapter window + a compact whole-timeline outline, not every item; include enriched scenes only for in-window assets, summarized past a cap; show the active AI scope in the prompt bar. **Budget: prompt context ≤ ~model-window/2 tokens at any project length; degrade by summarizing, never by silent truncation** |
+| **Scene/clip volume on long recordings** | A 2-hour podcast → hundreds–thousands of `Clip`s; tray + enrichment + Gemini cost explode | Virtualized, **paginated/searchable** clip tray (filter by `visual`/time/chapter); enrichment is **opt-in and chunked** (describe on demand / per chapter), scenes+proxy are free local passes; coarser default detector sensitivity for talking-head content (§11 Q7) to avoid over-splitting. **Budget: tray stays 60 fps at 2000+ clips (only visible rows mount)** |
+| **Navigating a multi-hour timeline** | Scrubbing/finding a moment across hours is painful | Chapters/markers (§5.6) with a jump list; fit-to-window and fit-to-selection zoom; a minimap/overview strip; playhead time-entry. **Budget: jump-to-chapter is O(1); overview always visible** |
+| **AI-timeline validity vs. hallucination** | Model may reference nonexistent items / bad times | AI returns a `TimelineDiff` **keyed to live item ids** (§5.7); validate ids + `0 ≤ in < out ≤ asset.duration` before applying; render as ghosted proposal for accept/reject; never silent-commit |
+| **Undo history bloats persisted state** | O(edits²) I/O / unbounded disk if kept in thread JSON | History moved to a **sidecar** `editor-history/{id}.json`, stored as **deltas** + sparse keyframes, **hard-capped at 50 steps** (ring buffer), rapid edits coalesced; document autosave decoupled from history growth |
+| **Multi-media data-model refactor cross-talk** | N media on a single-`videoPath` pipeline risks path collisions | Per-asset preprocessing target (`{assetId, baseDir=tempDir/media/{assetId}}`); namespaced task ids; **M1 spike gate** proves containment before UI wiring |
+| **Concurrency / disk under many imports** | Concurrent downscale+scenedetect+Gemini chains overload | Verify `backgroundTaskManager` queuing; if absent, add a bounded queue in M1. **Budget: ≤ K = 3 concurrent ffmpeg/scenedetect tasks**; cleanup on project delete |
+| **Timeline scale** | Many clips/frames tank framerate | Windowed virtualization. **Budget: 60 fps up to 300 on-screen clips**; beyond that only visible items mount |
+| **Gemini cost scales with clip count/length** | Per-scene descriptions add up on long recordings | Make description/transcript enrichment opt-in and chunked (per chapter / on demand); scenes+proxy+filmstrip are free local ffmpeg/scenedetect |
+| **Retime A/V drift** | `setpts`/`atempo` mismatch or `atempo` out-of-range → desync or artifacts | Chain `atempo` to stay in 0.5–2.0 per stage; render each retimed item so on-timeline length == `round((out−in)/speed)`; preview reflects the same rate via `<video>.playbackRate`; clamp speed to a sane range (e.g. 0.25×–4×) |
+| **Partial failure across N assets** | One bad import blocks the project | Per-asset error isolation + retry (§5.10); dependency-missing surfaces the existing install flow |
+| **Scope creep toward a full NLE** | Endless surface; slips ship date | Hard non-goals (§2); feature-sets, effects, pro trims, overlay authoring deferred with typed stubs |
+
+---
+
+## 9. Phased Delivery / Milestones
+
+*Status legend: ✅ shipped · ⚠️ shipped with noted deltas · ⏳ deferred. See §0 for the full ledger.*
+
+**M0 — Scaffolding.** ✅ New route `/editor/:id`, `VideoEditorPage.vue` full-bleed shell, Home "Video Editor" card, `create-editor-project` IPC, `Thread.type:'editor'` + `EditorDocument` types (with `preprocessing:{}`/`messages:[]` init), `editorStore` skeleton, empty-state UI. **Checklist:** audit chat-only `ThreadManager` consumers (`getBranchContext`, recovery, path-repair, `thread-updated`) and gate editor threads out of them.
+*Exit:* creating an editor project from Home opens a persistent, autosaving empty editor that appears on the Home grid, routes correctly, and trips no chat-only code path.
+
+**M1 — Media + preprocessing + selectable pieces (feature 2).** ⚠️ Media panel import (local + URL), **per-asset preprocessing scope spike (exit gate)**, background-task concurrency cap, scene→`Clip` derivation, clip tray with thumbnails, per-step live progress, detector sensitivity + merge/split, dependency-missing + per-asset error states (§5.10). *Delta: shipped except the **detector-sensitivity slider + merge/split** UI (backend `threshold` param exists) and per-asset **transcript** (only scene descriptions are wired, so `clip.text` is unused).*
+*Exit:* two videos (one local, one URL) import into one project; each auto-splits into selectable scene pieces with thumbnails and (opt-in) descriptions, with live per-asset progress, isolated failures, and no artifact collisions.
+
+**M2 — Timeline + manual edit + preview (features 3, 4, 5, 6-manual).** ⚠️ Purpose-built timeline (`pxPerSecond`, tracks video/audio/overlay), drag pieces onto tracks, program monitor EDL playback (with `playbackRate` honoring item `speed`), view toggle Filmstrip⇄Context, manual tools (trim/**retime-speed + numeric duration**/split/**cut/ripple**/move/snap/zoom/markers-chapters), **delta-based sidecar undo/redo**, keyboard shortcuts + a11y (§5.11). *Deltas deferred by choice: the **silence finder**, the **batched dense-filmstrip generator** (filmstrip mode shows one scene thumbnail per clip), long-timeline **minimap/overview + chapter jump list** (fit-to-window/selection did ship), and `prefers-reduced-motion` gating.*
+*Exit:* a user builds a multi-clip cut by hand across video+audio tracks by mouse **or keyboard**, toggles frames/context views, scrubs the monitor (< 100 ms), and undoes/redoes edits that survive restart.
+
+**M3 — Prompt + personas (features 6, 7).** ✅ Prompt bar, `run-editor-prompt` with persona system prompt, **item-id-keyed `TimelineDiff`** + id/bounds validation, persona library (predefined long-form + summarize + user CRUD, global `settingsManager` storage), persona picker/editor Modal grouped by mode, **AI context windowing for long projects** (§5.7), Gemini-error recovery (§5.10). *Note: the in-timeline **ghosting + accept/reject/partial** review was **superseded** by the revision rework (§5.7a) — results now apply immediately as a branchable revision.*
+*Exit:* a persona-driven prompt applies to the timeline as an `ai` revision (keyed to live ids, incl. a hand-split item); a follow-up prompt respects prior manual tweaks; a user-defined persona persists across projects.
+
+**M4 — Export.** ✅ Fast-path export via `assembleVideo` for single-source; `assembleTimeline` (segment-then-concat) for multi-clip/multi-source with per-item retime (`setpts`/`atempo`) + gaps + track/item mutes (§5.9); overlay/text export notice; `editor-render-progress` + abort; Save As / Open folder. *Note: v1 audio is single-active-source per region (no imported audio-kind assets yet), so the multi-source **`amix`** graph is structurally ready but not exercised.*
+*Exit:* a single-source highlight reel and a two-source multi-clip timeline both export to correct files matching the preview with synced audio; muting excludes a track; export is abortable.
+
+**Revisions rework (post-v1, `68225ae`).** ✅ Branchable revision tree (list + Vue Flow graph) replacing the M3 accept/reject flow — see §5.7a.
+
+**M5 — Deferred (feature 8 & beyond).** ⏳ Overlay/text track authoring, effects/transitions engine, persona feature-sets, PiP/transform compositing in `assembleTimeline`, pro trim modes — plus the M1/M2 deltas listed in §0 (silence finder, dense filmstrip, sensitivity/merge-split UI, minimap/jump-list, per-asset transcript, audio-kind assets, reduced-motion).
+*Exit (future):* n/a for v1 — schema stubs (`featureSets`, `effects`, `transform`, `transition`) already in place so this is additive.
+
+---
+
+## 10. Success Metrics & Acceptance Criteria
+
+**Product success metrics.**
+- **Adoption:** ≥30% of new projects in the first month post-ship are editor projects (`type:'editor'`).
+- **Manual+AI round trip:** ≥50% of editor projects that run a prompt also perform ≥1 manual edit afterward.
+- **Persona use:** ≥1 user-defined persona created by ≥15% of active editor users.
+- **Export completion:** ≥90% of started exports complete without error.
+- **Preprocessing reliability:** ≥95% of imported assets reach `preprocessState: completed` (scenes+proxy) without manual retry.
+
+**Release acceptance criteria (all must pass).**
+1. Editor project creates from Home (with `preprocessing:{}`/`messages:[]` initialized), persists, lists alongside chat/image threads, routes by `type`, and trips no chat-only code path.
+2. Two videos (local + URL) import into one project; each auto-splits into selectable pieces with thumbnails and, when enabled, `visual` descriptions; per-asset progress is live and failures isolate.
+3. With scenedetect uninstalled, the install flow is surfaced; a corrupt import errors only that asset with retry.
+4. Timeline supports video, audio, and overlay tracks; pieces drag onto tracks; overlay items are marked "not yet rendered."
+5. Filmstrip⇄Context toggle updates all visible clips without re-fetching source; context shows the enrichment `visual` string; filmstrip uses the batched generator.
+6. Manual tools (trim, split, move, ripple-delete, snap, zoom, markers) work by mouse **and** keyboard, are undoable via the capped sidecar history, and undo survives restart; snap is zoom-independent.
+7. A persona prompt returns a reviewable `TimelineDiff` keyed to live item ids (incl. a hand-split item), with partial accept/reject and id/bounds validation; a follow-up prompt reflects manual tweaks; the base version is untouched on rejection or Gemini error.
+8. Predefined personas exist in both **long-form** (length-preserving, e.g. `podcast-editor`) and **summarize** groups (read-only, cloneable); a new project defaults to a long-form persona; user personas persist globally.
+9. Export produces correct files for both the single-source fast path and a multi-source timeline with synced audio; muting excludes a track; a gap yields correct silence; overlay/text tracks trigger the export notice; export is abortable with progress.
+10. Timeline exposes ARIA roles/labels for tracks/clips/playhead and announces time on seek; editor shortcuts don't fire in text fields; `prefers-reduced-motion` suppresses decorative animation.
+11. Performance budgets met **at any project length**: scrub < 100 ms at proxy res; 60 fps up to 300 on-screen clips (tray 60 fps at 2000+ clips via virtualization); filmstrip for the visible window ≤ 8 s regardless of total length; AI prompt context ≤ ~half the model window via §5.7 windowing; ≤ 3 concurrent preprocessing tasks.
+12. No horizontal page-body scroll; timeline scrolls within its own container; dark and light themes both correct.
+
+---
+
+## 11. Open Questions
+
+1. **Extend `Thread` vs. new `EditorProject` store.** Recommended: extend (`type:'editor'` + `editor?`), reusing `ThreadManager` and the Home grid. *Resolution owned by the M0 checklist:* audit `getBranchContext`/recovery/path-repair for `videoPath`/`messages` assumptions and gate editor threads out.
+2. **v1 render fidelity.** Resolved in this revision: `assembleVideo` fast path + `assembleTimeline` P1 (multi-clip/multi-source + **mixed** audio via the §5.9 per-region graph); overlay/effects deferred. Remaining call: whether P1 surfaces per-item gain UI or fixes it at 1.0 (recommend fixed — the `gain` field is present but not exposed).
+3. **Persona storage.** Recommended: global `settingsManager` library (`personas` is a **net-new** field alongside `modelSettings`/key) + project-local `customPersonas[]`. Confirm `settingsManager` is the right home vs. a dedicated `personas.json`, and that it survives project deletion.
+4. **AI↔manual reconciliation when the base changed mid-flight.** Recommended (and specced in §5.7): validate the returned diff against `baseVersionId`, drop ids that no longer exist, surface a "based on an older version" notice, let the user re-run.
+5. **Enrichment cost policy.** Recommended: per-scene Gemini descriptions opt-in per asset; scenes+proxy+filmstrip free.
+6. **`versionCounter` reuse.** Repurpose `Thread.versionCounter`/`getNextVersion` for `EditorHistoryStep.seq` — confirm no collision with the chat editor's usage.
+7. **Detector sensitivity default.** Keep PySceneDetect's `-t 27.0`, or expose a coarser default tuned for lecture/talking-head content that over-splits less?
+8. **Icon set of record.** The SKILL doc says Solar; the code uses Tabler. Confirm Tabler for the editor and fix the SKILL doc (persona `icon` uses emoji or a Tabler id).
+9. **Retime bounds & pitch default.** Recommended: clamp `speed` to 0.25×–4×, `preservePitch=true` by default (`atempo`), opt-out to `asetrate`. Confirm the range and whether extreme slow-downs need frame interpolation (deferred — plain frame duplication for v1).
+10. **Silence-finder defaults & auto-mode.** What `silencedetect` thresholds (noise floor dB, min duration) default well for speech, and should there be a persona-triggered "propose all silence cuts" review (recommended: yes, review-only — never auto-commit, per §2)?
+11. **Long-form context-window thresholds.** Recommended defaults for §5.7 windowing: engage chapter-window mode past ~40 min / ~400 items; per-asset enriched-scene cap before summarization. Tune against real podcast lengths and the chosen model's context size.
+12. **Chapters as a first-class object?** v1 treats chapters as marker sugar. Decide whether long-form users need a dedicated `Chapter[]` model (titles, ranges) that also drives AI scoping and export chapter metadata (recommended for v1.1).
+
+---
+
+## 12. Appendix
+
+### Glossary
+- **Asset / MediaAsset:** an imported source file (video/image/audio) with its own proxy, preprocessing, and derived clips.
+- **Clip / Piece:** a selectable sub-segment derived from a detected scene (in/out into a source, + thumbnail + `visual` + transcript excerpt).
+- **TimelineItem / ClipInstance:** a placement of a clip on a track (`timelineStart` on the sequence, `in`/`out` into the source), addressed by a stable `id`.
+- **Track:** a timeline lane (`video`/`audio`/`overlay`/`text`), ordered for stacking.
+- **EDL playback:** renderer-side preview that plays proxies through a `<video>` element, switching at clip boundaries — not a live composite.
+- **Enriched master timeline:** `EnrichedTimelineSegment[]` merging transcript + per-scene `visual` descriptions; the bridge between AI selection and editor clips.
+- **Persona:** a named, swappable AI system-prompt profile (+ typed defaults); future feature-sets bind effect groups.
+- **TimelineDiff:** structured AI proposal (add/remove/update items, add/remove tracks) **keyed to live item ids**, reviewed via accept/reject before commit.
+- **History step / delta:** a forward+inverse `TimelineDiff` pair in the capped sidecar history; undo/redo replays deltas from the nearest keyframe.
+- **Version:** in the editor, a *committed history step*. The `baseVersionId` / `versionId` in the prompt and export APIs refer to an `EditorHistoryStep.id` — the two vocabularies name the same thing.
+- **Segment-then-concat:** the multi-source render strategy — bounded per-region video+audio filtergraphs stitched by the concat demuxer.
+- **Per-region audio graph:** for each concat region, the mix of that region's unmuted streams (`amix`, normalized to 48 kHz stereo, silence via `anullsrc`/`apad`) that preserves A/V sync.
+- **Proxy:** a 480p low-res copy (`toLowResolution`) used for fast scrubbing/thumbnails; originals used for final render.
+- **Retime / Speed:** a constant per-item playback-rate change (`TimelineItem.speed`) that reduces (>1×) or extends (<1×) a section's on-timeline duration; rendered via `setpts`/`atempo`.
+- **Cut:** split at the playhead then delete/ripple-delete — the third way (with trim and retime) to adjust a section's timing.
+- **Long-form persona:** a length-preserving editorial persona (`mode:'longform'`, `targetDurationSec:null`) that cleans/retimes/reorders/chapters without a shrink goal (e.g. `podcast-editor`), vs. a summarize persona that targets a shorter duration.
+- **Silence finder:** an assistive pass (`silencedetect`) that proposes low-energy cut ranges the user reviews — never auto-commits.
+- **AI context windowing:** bounding the model's input on long projects to the selection/chapter window + a compact outline (§5.7), so token cost stays flat regardless of runtime.
+- **Chapter / marker:** a time bookmark used to navigate long timelines and to scope AI edits; may seed export chapter metadata (deferred).
+
+### Feature → PRD section traceability
+
+| # | Requested feature | Covered in |
+|---|---|---|
+| 1 | Looks like a popular editor (media/browser, monitor, timeline, rails, inspector) | §4 UI/Layout Spec (wireframe + component tree + design system) |
+| 2 | Media panel; add videos; per-video preprocess; broken into selectable pieces | §5.1 Media Panel & Import; §5.2 Preprocessing & Auto Scene-Splitting (+ per-asset scope refactor); data model `MediaAsset`/`Clip` (§6) |
+| 3 | Preview + timeline; drag videos/pieces into the timeline | §5.3 Preview/Program Monitor; §5.4 Timeline & Tracks; `clipToItem` (§6) |
+| 4 | Toggle frames-preview vs context-preview | §5.5 Timeline View Toggle (grounded in `EnrichedTimelineSegment.visual`) |
+| 5 | Different tracks: audio, video, and "other objects" | §5.4 Timeline & Tracks; `Track.kind` (§6); export semantics §5.9 |
+| 6 | Prompt box to edit + manual editing | §5.6 Manual Editing Tools; §5.7 Prompt Box / AI Editing (item-id contract); §5.11 keyboard |
+| 7 | Editor personas — predefined + user-defined | §5.8 Editor Personas; `EditorPersona` (§6); `get/set-personas` (§7) |
+| 8 | Personas backed by feature-sets (later; text enough now) | §5.8 (deferred note); `featureSets` stub in `EditorPersona` (§6); §2 Non-Goals; §9 M5 |
+
+### Added-requirement traceability (this revision)
+
+| Requirement | Covered in |
+|---|---|
+| Editor serves **long videos**, not only summaries (podcasts, vlogs, …) | §1 (length-agnostic + audience); §2 goals; §8 (long-video scalability rows); §5.7 AI context windowing |
+| **Personas for long-form editors** (not just summarizers) | §5.8 long-form persona group (`podcast-editor`, `longform-polish`, `silence-cleaner`, `chapter-organizer`, `study-notes`); `mode`/null-duration in `EditorPersona` (§6); default persona = `podcast-editor` |
+| **Adjust a section's timing — reduce / extend / cut** | §5.6 (trim = reduce/extend by content; retime/speed = reduce/extend by rate + numeric duration; cut = split + ripple-delete); `TimelineItem.speed`/`preservePitch` (§6); render via `setpts`/`atempo` (§5.9, §7); retime risk (§8) |
+| **Modularity & scalability** (the direct question) | §7 Modularity & Extensibility (module boundary + registries + handler-based render + versioned diff); §8 scalability budgets |
\ No newline at end of file
diff --git a/yarn.lock b/yarn.lock
index b56fed0..c0d3192 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2,11 +2,6 @@
 # yarn lockfile v1
 
 
-"7zip-bin@~5.2.0":
-  version "5.2.0"
-  resolved "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.2.0.tgz"
-  integrity sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==
-
 "@alloc/quick-lru@^5.2.0":
   version "5.2.0"
   resolved "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz"
@@ -26,7 +21,7 @@
   resolved "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz"
   integrity sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==
 
-"@babel/core@^7.24.7":
+"@babel/core@^7.0.0", "@babel/core@^7.0.0-0", "@babel/core@^7.24.7":
   version "7.29.0"
   resolved "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz"
   integrity sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==
@@ -249,121 +244,11 @@
     minimatch "^3.0.4"
     plist "^3.0.4"
 
-"@esbuild/aix-ppc64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz#c7184a326533fcdf1b8ee0733e21c713b975575f"
-  integrity sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==
-
-"@esbuild/android-arm64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz#09d9b4357780da9ea3a7dfb833a1f1ff439b4052"
-  integrity sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==
-
-"@esbuild/android-arm@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz#9b04384fb771926dfa6d7ad04324ecb2ab9b2e28"
-  integrity sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==
-
-"@esbuild/android-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz#29918ec2db754cedcb6c1b04de8cd6547af6461e"
-  integrity sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==
-
 "@esbuild/darwin-arm64@0.21.5":
   version "0.21.5"
   resolved "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz"
   integrity sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==
 
-"@esbuild/darwin-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz#c13838fa57372839abdddc91d71542ceea2e1e22"
-  integrity sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==
-
-"@esbuild/freebsd-arm64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz#646b989aa20bf89fd071dd5dbfad69a3542e550e"
-  integrity sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==
-
-"@esbuild/freebsd-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz#aa615cfc80af954d3458906e38ca22c18cf5c261"
-  integrity sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==
-
-"@esbuild/linux-arm64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz#70ac6fa14f5cb7e1f7f887bcffb680ad09922b5b"
-  integrity sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==
-
-"@esbuild/linux-arm@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz#fc6fd11a8aca56c1f6f3894f2bea0479f8f626b9"
-  integrity sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==
-
-"@esbuild/linux-ia32@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz#3271f53b3f93e3d093d518d1649d6d68d346ede2"
-  integrity sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==
-
-"@esbuild/linux-loong64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz#ed62e04238c57026aea831c5a130b73c0f9f26df"
-  integrity sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==
-
-"@esbuild/linux-mips64el@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz#e79b8eb48bf3b106fadec1ac8240fb97b4e64cbe"
-  integrity sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==
-
-"@esbuild/linux-ppc64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz#5f2203860a143b9919d383ef7573521fb154c3e4"
-  integrity sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==
-
-"@esbuild/linux-riscv64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz#07bcafd99322d5af62f618cb9e6a9b7f4bb825dc"
-  integrity sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==
-
-"@esbuild/linux-s390x@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz#b7ccf686751d6a3e44b8627ababc8be3ef62d8de"
-  integrity sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==
-
-"@esbuild/linux-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz#6d8f0c768e070e64309af8004bb94e68ab2bb3b0"
-  integrity sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==
-
-"@esbuild/netbsd-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz#bbe430f60d378ecb88decb219c602667387a6047"
-  integrity sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==
-
-"@esbuild/openbsd-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz#99d1cf2937279560d2104821f5ccce220cb2af70"
-  integrity sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==
-
-"@esbuild/sunos-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz#08741512c10d529566baba837b4fe052c8f3487b"
-  integrity sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==
-
-"@esbuild/win32-arm64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz#675b7385398411240735016144ab2e99a60fc75d"
-  integrity sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==
-
-"@esbuild/win32-ia32@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz#1bfc3ce98aa6ca9a0969e4d2af72144c59c1193b"
-  integrity sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==
-
-"@esbuild/win32-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz#acad351d582d157bb145535db2a6ff53dd514b5c"
-  integrity sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==
-
 "@google/genai@^1.40.0":
   version "1.41.0"
   resolved "https://registry.npmjs.org/@google/genai/-/genai-1.41.0.tgz"
@@ -471,7 +356,7 @@
     "@nodelib/fs.stat" "2.0.5"
     run-parallel "^1.1.9"
 
-"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
+"@nodelib/fs.stat@^2.0.2", "@nodelib/fs.stat@2.0.5":
   version "2.0.5"
   resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz"
   integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
@@ -547,152 +432,54 @@
   resolved "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz"
   integrity sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==
 
-"@rollup/rollup-android-arm-eabi@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.57.1.tgz#add5e608d4e7be55bc3ca3d962490b8b1890e088"
-  integrity sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg==
-
-"@rollup/rollup-android-arm64@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.57.1.tgz#10bd0382b73592beee6e9800a69401a29da625c4"
-  integrity sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w==
-
 "@rollup/rollup-darwin-arm64@4.57.1":
   version "4.57.1"
   resolved "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.57.1.tgz"
   integrity sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg==
 
-"@rollup/rollup-darwin-x64@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.57.1.tgz#69e741aeb2839d2e8f0da2ce7a33d8bd23632423"
-  integrity sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w==
-
-"@rollup/rollup-freebsd-arm64@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.57.1.tgz#3736c232a999c7bef7131355d83ebdf9651a0839"
-  integrity sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug==
-
-"@rollup/rollup-freebsd-x64@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.57.1.tgz#227dcb8f466684070169942bd3998901c9bfc065"
-  integrity sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q==
-
-"@rollup/rollup-linux-arm-gnueabihf@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.57.1.tgz#ba004b30df31b724f99ce66e7128248bea17cb0c"
-  integrity sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw==
-
-"@rollup/rollup-linux-arm-musleabihf@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.57.1.tgz#6929f3e07be6b6da5991f63c6b68b3e473d0a65a"
-  integrity sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw==
-
-"@rollup/rollup-linux-arm64-gnu@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.57.1.tgz#06e89fd4a25d21fe5575d60b6f913c0e65297bfa"
-  integrity sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g==
-
-"@rollup/rollup-linux-arm64-musl@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.57.1.tgz#fddabf395b90990d5194038e6cd8c00156ed8ac0"
-  integrity sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q==
-
-"@rollup/rollup-linux-loong64-gnu@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.57.1.tgz#04c10bb764bbf09a3c1bd90432e92f58d6603c36"
-  integrity sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA==
-
-"@rollup/rollup-linux-loong64-musl@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.57.1.tgz#f2450361790de80581d8687ea19142d8a4de5c0f"
-  integrity sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw==
-
-"@rollup/rollup-linux-ppc64-gnu@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.57.1.tgz#0474f4667259e407eee1a6d38e29041b708f6a30"
-  integrity sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w==
-
-"@rollup/rollup-linux-ppc64-musl@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.57.1.tgz#9f32074819eeb1ddbe51f50ea9dcd61a6745ec33"
-  integrity sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw==
-
-"@rollup/rollup-linux-riscv64-gnu@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.57.1.tgz#3fdb9d4b1e29fb6b6a6da9f15654d42eb77b99b2"
-  integrity sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A==
-
-"@rollup/rollup-linux-riscv64-musl@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.57.1.tgz#1de780d64e6be0e3e8762035c22e0d8ea68df8ed"
-  integrity sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw==
-
-"@rollup/rollup-linux-s390x-gnu@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.57.1.tgz#1da022ffd2d9e9f0fd8344ea49e113001fbcac64"
-  integrity sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg==
-
-"@rollup/rollup-linux-x64-gnu@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.57.1.tgz#78c16eef9520bd10e1ea7a112593bb58e2842622"
-  integrity sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg==
-
-"@rollup/rollup-linux-x64-musl@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.57.1.tgz#a7598591b4d9af96cb3167b50a5bf1e02dfea06c"
-  integrity sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw==
-
-"@rollup/rollup-openbsd-x64@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.57.1.tgz#c51d48c07cd6c466560e5bed934aec688ce02614"
-  integrity sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw==
-
-"@rollup/rollup-openharmony-arm64@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.57.1.tgz#f09921d0b2a0b60afbf3586d2a7a7f208ba6df17"
-  integrity sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ==
-
-"@rollup/rollup-win32-arm64-msvc@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.57.1.tgz#08d491717135376e4a99529821c94ecd433d5b36"
-  integrity sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ==
-
-"@rollup/rollup-win32-ia32-msvc@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.57.1.tgz#b0c12aac1104a8b8f26a5e0098e5facbb3e3964a"
-  integrity sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew==
-
-"@rollup/rollup-win32-x64-gnu@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.57.1.tgz#b9cccef26f5e6fdc013bf3c0911a3c77428509d0"
-  integrity sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ==
-
-"@rollup/rollup-win32-x64-msvc@4.57.1":
-  version "4.57.1"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.57.1.tgz#a03348e7b559c792b6277cc58874b89ef46e1e72"
-  integrity sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==
-
 "@sindresorhus/is@^4.0.0":
   version "4.6.0"
   resolved "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz"
   integrity sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==
 
 "@storybook/builder-vite@^8.4.5":
-  version "8.6.15"
-  resolved "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-8.6.15.tgz"
-  integrity sha512-9Y05/ndZE6/eI7ZIUCD/QtH2htRIUs9j1gxE6oW0zRo9TJO1iqxfLNwgzd59KEkId7gdZxPei0l+LGTUGXYKRg==
+  version "8.6.18"
+  resolved "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-8.6.18.tgz"
+  integrity sha512-XLqnOv4C36jlTd4uC8xpWBxv+7GV4/05zWJ0wAcU4qflorropUTirt4UQPGkwIzi+BVAhs9pJj+m4k0IWJtpHg==
   dependencies:
-    "@storybook/csf-plugin" "8.6.15"
+    "@storybook/csf-plugin" "8.6.18"
     browser-assert "^1.2.1"
     ts-dedent "^2.0.0"
 
-"@storybook/csf-plugin@8.6.15":
-  version "8.6.15"
-  resolved "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-8.6.15.tgz"
-  integrity sha512-ZLz/mtOoE1Jj2lE4pK3U7MmYrv5+lot3mGtwxGb832tcABMc97j9O+reCVxZYc7DeFbBuuEdMT9rBL/O3kXYmw==
+"@storybook/core@8.6.18":
+  version "8.6.18"
+  resolved "https://registry.npmjs.org/@storybook/core/-/core-8.6.18.tgz"
+  integrity sha512-dRBP2TnX6fGdS0T2mXBHjkS/3Nlu1ra1huovZVFuM67CYMzrhM/3hX/zru1vWSC5rqY93ZaAhjMciPW4pK5mMQ==
+  dependencies:
+    "@storybook/theming" "8.6.18"
+    better-opn "^3.0.2"
+    browser-assert "^1.2.1"
+    esbuild "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0"
+    esbuild-register "^3.5.0"
+    jsdoc-type-pratt-parser "^4.0.0"
+    process "^0.11.10"
+    recast "^0.23.5"
+    semver "^7.6.2"
+    util "^0.12.5"
+    ws "^8.2.3"
+
+"@storybook/csf-plugin@8.6.18":
+  version "8.6.18"
+  resolved "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-8.6.18.tgz"
+  integrity sha512-x1ioz/L0CwaelCkHci3P31YtvwayN3FBftvwQOPbvRh9qeb4Cpz5IdVDmyvSxxYwXN66uAORNoqgjTi7B4/y5Q==
   dependencies:
     unplugin "^1.3.1"
 
+"@storybook/theming@8.6.18":
+  version "8.6.18"
+  resolved "https://registry.npmjs.org/@storybook/theming/-/theming-8.6.18.tgz"
+  integrity sha512-n6OEjEtHupa2PdTwWzRepr7cO8NkDd4rgF6BKLitRbujOspLxzMBEqdphs+QLcuiCIgf33SqmEA64QWnbSMhPw==
+
 "@szmarczak/http-timer@^4.0.5":
   version "4.0.6"
   resolved "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz"
@@ -707,28 +494,23 @@
   dependencies:
     postcss-selector-parser "6.0.10"
 
-"@tanstack/virtual-core@3.13.18":
-  version "3.13.18"
-  resolved "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.13.18.tgz"
-  integrity sha512-Mx86Hqu1k39icq2Zusq+Ey2J6dDWTjDvEv43PJtRCoEYTLyfaPnxIQ6iy7YAOK0NV/qOEmZQ/uCufrppZxTgcg==
+"@tanstack/virtual-core@3.17.4":
+  version "3.17.4"
+  resolved "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.17.4.tgz"
+  integrity sha512-nGm5KteqxasUdThLc2izl6dHUqLv0LQj7Nuyo5gYalTPf/U8a9ermvsl7reT+6ioBW1l8WfpP/mcU338nLXpqw==
 
 "@tanstack/vue-virtual@^3.0.0-beta.60":
-  version "3.13.18"
-  resolved "https://registry.npmjs.org/@tanstack/vue-virtual/-/vue-virtual-3.13.18.tgz"
-  integrity sha512-6pT8HdHtTU5Z+t906cGdCroUNA5wHjFXsNss9gwk7QAr1VNZtz9IQCs2Nhx0gABK48c+OocHl2As+TMg8+Hy4A==
+  version "3.13.32"
+  resolved "https://registry.npmjs.org/@tanstack/vue-virtual/-/vue-virtual-3.13.32.tgz"
+  integrity sha512-E8OCutx7QnwZdvpJijz0Q2PHsYDWBWjnGr3TvgWiqxTU35jB1kVhtkd93scRV7tTFuId2tg3x2iFiw+IE4evjQ==
   dependencies:
-    "@tanstack/virtual-core" "3.13.18"
+    "@tanstack/virtual-core" "3.17.4"
 
 "@tootallnate/once@2":
   version "2.0.0"
   resolved "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.0.tgz"
   integrity sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==
 
-"@trysound/sax@0.2.0":
-  version "0.2.0"
-  resolved "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz"
-  integrity sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==
-
 "@types/cacheable-request@^6.0.1":
   version "6.0.3"
   resolved "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz"
@@ -758,7 +540,7 @@
   dependencies:
     "@types/node" "*"
 
-"@types/fs-extra@9.0.13", "@types/fs-extra@^9.0.11":
+"@types/fs-extra@^9.0.11", "@types/fs-extra@9.0.13":
   version "9.0.13"
   resolved "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz"
   integrity sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==
@@ -800,7 +582,7 @@
   resolved "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz"
   integrity sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==
 
-"@types/node@*", "@types/node@>=13.7.0", "@types/node@^25.2.3":
+"@types/node@*", "@types/node@^18.0.0 || >=20.0.0", "@types/node@^25.2.3", "@types/node@>=13.7.0":
   version "25.2.3"
   resolved "https://registry.npmjs.org/@types/node/-/node-25.2.3.tgz"
   integrity sha512-m0jEgYlYz+mDJZ2+F4v8D1AyQb+QzsNqRuI7xg1VQX/KlKS0qT9r1Mo16yo5F/MtifXFgaofIFsdFMox2SxIbQ==
@@ -892,7 +674,7 @@
   resolved "https://registry.npmjs.org/@vue-flow/controls/-/controls-1.1.3.tgz"
   integrity sha512-XCf+G+jCvaWURdFlZmOjifZGw3XMhN5hHlfMGkWh9xot+9nH9gdTZtn+ldIJKtarg3B21iyHU8JjKDhYcB6JMw==
 
-"@vue-flow/core@^1.48.2":
+"@vue-flow/core@^1.23.0", "@vue-flow/core@^1.48.2":
   version "1.48.2"
   resolved "https://registry.npmjs.org/@vue-flow/core/-/core-1.48.2.tgz"
   integrity sha512-raxhgKWE+G/mcEvXJjGFUDYW9rAI3GOtiHR3ZkNpwBWuIaCC1EYiBmKGwJOoNzVFgwO7COgErnK7i08i287AFA==
@@ -914,7 +696,7 @@
     estree-walker "^2.0.2"
     source-map-js "^1.2.1"
 
-"@vue/compiler-dom@3.5.28", "@vue/compiler-dom@^3.5.0":
+"@vue/compiler-dom@^3.5.0", "@vue/compiler-dom@3.5.28":
   version "3.5.28"
   resolved "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.28.tgz"
   integrity sha512-/1ZepxAb159jKR1btkefDP+J2xuWL5V3WtleRmxaT+K2Aqiek/Ab/+Ebrw2pPj0sdHO8ViAyyJWfhXXOP/+LQA==
@@ -1032,7 +814,7 @@
     "@vue/compiler-ssr" "3.5.28"
     "@vue/shared" "3.5.28"
 
-"@vue/shared@3.5.28", "@vue/shared@^3.5.0":
+"@vue/shared@^3.5.0", "@vue/shared@3.5.28":
   version "3.5.28"
   resolved "https://registry.npmjs.org/@vue/shared/-/shared-3.5.28.tgz"
   integrity sha512-cfWa1fCGBxrvaHRhvV3Is0MgmrbSCxYTXCSCau2I0a1Xw1N1pHAvkWCiXPRAqjvToILvguNyEwjevUqAuBQWvQ==
@@ -1061,13 +843,6 @@
   resolved "https://registry.npmjs.org/@vueuse/metadata/-/metadata-10.11.1.tgz"
   integrity sha512-IGa5FXd003Ug1qAZmyE8wF3sJ81xGLSqTqtQ6jaVfkeZ4i5kS2mwQF61yhVqojRnenVew5PldLyRgvdl4YYuSw==
 
-"@vueuse/shared@10.11.1":
-  version "10.11.1"
-  resolved "https://registry.npmjs.org/@vueuse/shared/-/shared-10.11.1.tgz"
-  integrity sha512-LHpC8711VFZlDaYUXEBbFBCQ7GS3dVU9mjOhhMhXP6txTV4EhYQg/KGnQuvt/sPAtoUKq7VVUnL6mVtFoL42sA==
-  dependencies:
-    vue-demi ">=0.14.8"
-
 "@vueuse/shared@^9.2.0", "@vueuse/shared@^9.3.0":
   version "9.13.0"
   resolved "https://registry.npmjs.org/@vueuse/shared/-/shared-9.13.0.tgz"
@@ -1075,6 +850,13 @@
   dependencies:
     vue-demi "*"
 
+"@vueuse/shared@10.11.1":
+  version "10.11.1"
+  resolved "https://registry.npmjs.org/@vueuse/shared/-/shared-10.11.1.tgz"
+  integrity sha512-LHpC8711VFZlDaYUXEBbFBCQ7GS3dVU9mjOhhMhXP6txTV4EhYQg/KGnQuvt/sPAtoUKq7VVUnL6mVtFoL42sA==
+  dependencies:
+    vue-demi ">=0.14.8"
+
 "@xmldom/xmldom@^0.8.8":
   version "0.8.11"
   resolved "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.11.tgz"
@@ -1096,15 +878,25 @@
     "@zhead/schema" "0.8.5"
     "@zhead/schema-raw" "0.8.5"
 
-"@zhead/schema@0.8.5", "@zhead/schema@^0.8.5":
+"@zhead/schema@^0.8.5", "@zhead/schema@0.8.5":
   version "0.8.5"
   resolved "https://registry.npmjs.org/@zhead/schema/-/schema-0.8.5.tgz"
   integrity sha512-1S3Otr2zpl1zwP72dNseVXQNG9tnTQ6hHUEUYwINvBjRj6bHcUwdE+Itc9OLxnGAJT/7p8P7GHGo5sshXJNJsA==
 
+"7zip-bin@~5.2.0":
+  version "5.2.0"
+  resolved "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.2.0.tgz"
+  integrity sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==
+
 acorn@^8.14.0:
-  version "8.15.0"
-  resolved "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz"
-  integrity sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==
+  version "8.17.0"
+  resolved "https://registry.npmjs.org/acorn/-/acorn-8.17.0.tgz"
+  integrity sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==
+
+agent-base@^7.1.2:
+  version "7.1.4"
+  resolved "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz"
+  integrity sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==
 
 agent-base@6:
   version "6.0.2"
@@ -1113,17 +905,12 @@ agent-base@6:
   dependencies:
     debug "4"
 
-agent-base@^7.1.2:
-  version "7.1.4"
-  resolved "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz"
-  integrity sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==
-
 ajv-keywords@^3.4.1:
   version "3.5.2"
   resolved "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz"
   integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
 
-ajv@^6.10.0, ajv@^6.12.0:
+ajv@^6.10.0, ajv@^6.12.0, ajv@^6.9.1:
   version "6.12.6"
   resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
@@ -1211,6 +998,51 @@ app-builder-lib@24.13.3:
     tar "^6.1.12"
     temp-file "^3.4.0"
 
+archiver-utils@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/archiver-utils/-/archiver-utils-2.1.0.tgz"
+  integrity sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==
+  dependencies:
+    glob "^7.1.4"
+    graceful-fs "^4.2.0"
+    lazystream "^1.0.0"
+    lodash.defaults "^4.2.0"
+    lodash.difference "^4.5.0"
+    lodash.flatten "^4.4.0"
+    lodash.isplainobject "^4.0.6"
+    lodash.union "^4.6.0"
+    normalize-path "^3.0.0"
+    readable-stream "^2.0.0"
+
+archiver-utils@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.npmjs.org/archiver-utils/-/archiver-utils-3.0.4.tgz"
+  integrity sha512-KVgf4XQVrTjhyWmx6cte4RxonPLR9onExufI1jhvw/MQ4BB6IsZD5gT8Lq+u/+pRkWna/6JoHpiQioaqFP5Rzw==
+  dependencies:
+    glob "^7.2.3"
+    graceful-fs "^4.2.0"
+    lazystream "^1.0.0"
+    lodash.defaults "^4.2.0"
+    lodash.difference "^4.5.0"
+    lodash.flatten "^4.4.0"
+    lodash.isplainobject "^4.0.6"
+    lodash.union "^4.6.0"
+    normalize-path "^3.0.0"
+    readable-stream "^3.6.0"
+
+archiver@^5.3.1:
+  version "5.3.2"
+  resolved "https://registry.npmjs.org/archiver/-/archiver-5.3.2.tgz"
+  integrity sha512-+25nxyyznAXF7Nef3y0EbBeqmGZgeN/BxHX29Rs39djAfaFalmQ89SE6CWyDCHzGL0yt/ycBtNOmGTW0FyGWNw==
+  dependencies:
+    archiver-utils "^2.1.0"
+    async "^3.2.4"
+    buffer-crc32 "^0.2.1"
+    readable-stream "^3.6.0"
+    readdir-glob "^1.1.2"
+    tar-stream "^2.2.0"
+    zip-stream "^4.1.0"
+
 arg@^5.0.2:
   version "5.0.2"
   resolved "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz"
@@ -1226,6 +1058,13 @@ assert-plus@^1.0.0:
   resolved "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz"
   integrity sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==
 
+ast-types@^0.16.1:
+  version "0.16.1"
+  resolved "https://registry.npmjs.org/ast-types/-/ast-types-0.16.1.tgz"
+  integrity sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg==
+  dependencies:
+    tslib "^2.0.1"
+
 astral-regex@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz"
@@ -1241,6 +1080,11 @@ async@^0.2.9:
   resolved "https://registry.npmjs.org/async/-/async-0.2.10.tgz"
   integrity sha512-eAkdoKxU6/LkKDBzLpT+t6Ff5EtfSF4wx1WfJiPEEV7WNLnDaRXk0oVysiEPm262roaachGexwUv94WhSgN5TQ==
 
+async@^3.2.4:
+  version "3.2.6"
+  resolved "https://registry.npmjs.org/async/-/async-3.2.6.tgz"
+  integrity sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==
+
 async@^3.2.6:
   version "3.2.6"
   resolved "https://registry.npmjs.org/async/-/async-3.2.6.tgz"
@@ -1267,6 +1111,13 @@ autoprefixer@^10.4.19:
     picocolors "^1.1.1"
     postcss-value-parser "^4.2.0"
 
+available-typed-arrays@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz"
+  integrity sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==
+  dependencies:
+    possible-typed-array-names "^1.0.0"
+
 balanced-match@^1.0.0:
   version "1.0.2"
   resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
@@ -1282,6 +1133,13 @@ baseline-browser-mapping@^2.9.0:
   resolved "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.19.tgz"
   integrity sha512-ipDqC8FrAl/76p2SSWKSI+H9tFwm7vYqXQrItCuiVPt26Km0jS+NzSsBWAaBusvSbQcfJG+JitdMm+wZAgTYqg==
 
+better-opn@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.npmjs.org/better-opn/-/better-opn-3.0.2.tgz"
+  integrity sha512-aVNobHnJqLiUelTaHat9DZ1qM2w0C0Eym4LPI/3JxOnSokGVdsl1T1kN7TFvsEAD8G47A6VKQ0TVHqbBnYMJlQ==
+  dependencies:
+    open "^8.0.4"
+
 bignumber.js@^9.0.0:
   version "9.3.1"
   resolved "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.1.tgz"
@@ -1297,6 +1155,15 @@ birpc@^2.3.0:
   resolved "https://registry.npmjs.org/birpc/-/birpc-2.9.0.tgz"
   integrity sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==
 
+bl@^4.0.3:
+  version "4.1.0"
+  resolved "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz"
+  integrity sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==
+  dependencies:
+    buffer "^5.5.0"
+    inherits "^2.0.4"
+    readable-stream "^3.4.0"
+
 bluebird-lst@^1.0.9:
   version "1.0.9"
   resolved "https://registry.npmjs.org/bluebird-lst/-/bluebird-lst-1.0.9.tgz"
@@ -1346,7 +1213,7 @@ browser-assert@^1.2.1:
   resolved "https://registry.npmjs.org/browser-assert/-/browser-assert-1.2.1.tgz"
   integrity sha512-nfulgvOR6S4gt9UKCeGJOuSGBPGiFT6oQ/2UBnvTY/5aQ1PnksW72fhZkM30DzoRRv2WpwZf1vHHEr3mtuXIWQ==
 
-browserslist@^4.0.0, browserslist@^4.21.4, browserslist@^4.24.0, browserslist@^4.28.1:
+browserslist@^4.0.0, browserslist@^4.21.4, browserslist@^4.24.0, browserslist@^4.28.1, "browserslist@>= 4.21.0":
   version "4.28.1"
   resolved "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz"
   integrity sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==
@@ -1357,7 +1224,7 @@ browserslist@^4.0.0, browserslist@^4.21.4, browserslist@^4.24.0, browserslist@^4
     node-releases "^2.0.27"
     update-browserslist-db "^1.2.0"
 
-buffer-crc32@~0.2.3:
+buffer-crc32@^0.2.1, buffer-crc32@^0.2.13, buffer-crc32@~0.2.3:
   version "0.2.13"
   resolved "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz"
   integrity sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==
@@ -1377,7 +1244,7 @@ buffer-from@^1.0.0:
   resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz"
   integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
 
-buffer@^5.1.0:
+buffer@^5.1.0, buffer@^5.5.0:
   version "5.7.1"
   resolved "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz"
   integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==
@@ -1398,8 +1265,8 @@ builder-util@24.13.1:
   resolved "https://registry.npmjs.org/builder-util/-/builder-util-24.13.1.tgz"
   integrity sha512-NhbCSIntruNDTOVI9fdXz0dihaqX2YuE1D6zZMrwiErzH4ELZHE6mdiB40wEgZNprDia+FghRFgKoAqMZRRjSA==
   dependencies:
-    "7zip-bin" "~5.2.0"
     "@types/debug" "^4.1.6"
+    "7zip-bin" "~5.2.0"
     app-builder-bin "4.0.0"
     bluebird-lst "^1.0.9"
     builder-util-runtime "9.2.4"
@@ -1446,6 +1313,24 @@ call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2:
     es-errors "^1.3.0"
     function-bind "^1.1.2"
 
+call-bind@^1.0.9:
+  version "1.0.9"
+  resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.9.tgz"
+  integrity sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==
+  dependencies:
+    call-bind-apply-helpers "^1.0.2"
+    es-define-property "^1.0.1"
+    get-intrinsic "^1.3.0"
+    set-function-length "^1.2.2"
+
+call-bound@^1.0.2, call-bound@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz"
+  integrity sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==
+  dependencies:
+    call-bind-apply-helpers "^1.0.2"
+    get-intrinsic "^1.3.0"
+
 camelcase-css@^2.0.1:
   version "2.0.1"
   resolved "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz"
@@ -1577,6 +1462,16 @@ compare-version@^0.1.2:
   resolved "https://registry.npmjs.org/compare-version/-/compare-version-0.1.2.tgz"
   integrity sha512-pJDh5/4wrEnXX/VWRZvruAGHkzKdr46z11OlTPN+VrATlWWhSKewNCJ1futCO5C7eJB3nPMFZA1LeYtcFboZ2A==
 
+compress-commons@^4.1.2:
+  version "4.1.2"
+  resolved "https://registry.npmjs.org/compress-commons/-/compress-commons-4.1.2.tgz"
+  integrity sha512-D3uMHtGc/fcO1Gt1/L7i1e33VOvD4A9hfQLP+6ewd+BvG/gQ84Yh4oftEhAdjSMgBgwGL+jsppT7JYNpo6MHHg==
+  dependencies:
+    buffer-crc32 "^0.2.13"
+    crc32-stream "^4.0.2"
+    normalize-path "^3.0.0"
+    readable-stream "^3.6.0"
+
 concat-map@0.0.1:
   version "0.0.1"
   resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz"
@@ -1612,11 +1507,16 @@ copy-anything@^4:
   dependencies:
     is-what "^5.2.0"
 
-core-util-is@1.0.2:
+core-util-is@~1.0.0, core-util-is@1.0.2:
   version "1.0.2"
   resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz"
   integrity sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==
 
+crc-32@^1.2.0:
+  version "1.2.2"
+  resolved "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz"
+  integrity sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==
+
 crc@^3.8.0:
   version "3.8.0"
   resolved "https://registry.npmjs.org/crc/-/crc-3.8.0.tgz"
@@ -1624,6 +1524,14 @@ crc@^3.8.0:
   dependencies:
     buffer "^5.1.0"
 
+crc32-stream@^4.0.2:
+  version "4.0.3"
+  resolved "https://registry.npmjs.org/crc32-stream/-/crc32-stream-4.0.3.tgz"
+  integrity sha512-NT7w2JVU7DFroFdYkeq8cywxrgjPHWkdX1wjpRQXPX5Asews3tA+Ght6lddQO5Mkumffp3X7GEqku3epj2toIw==
+  dependencies:
+    crc-32 "^1.2.0"
+    readable-stream "^3.4.0"
+
 cross-spawn@^7.0.1, cross-spawn@^7.0.3, cross-spawn@^7.0.6:
   version "7.0.6"
   resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz"
@@ -1738,7 +1646,7 @@ csstype@^3.2.3:
   resolved "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz"
   integrity sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==
 
-"d3-drag@2 - 3", d3-drag@^3.0.0:
+d3-drag@^3.0.0, "d3-drag@2 - 3":
   version "3.0.0"
   resolved "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz"
   integrity sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==
@@ -1751,14 +1659,14 @@ csstype@^3.2.3:
   resolved "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz"
   integrity sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==
 
-"d3-interpolate@1 - 3", d3-interpolate@^3.0.1:
+d3-interpolate@^3.0.1, "d3-interpolate@1 - 3":
   version "3.0.1"
   resolved "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz"
   integrity sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==
   dependencies:
     d3-color "1 - 3"
 
-"d3-selection@2 - 3", d3-selection@3, d3-selection@^3.0.0:
+d3-selection@^3.0.0, "d3-selection@2 - 3", d3-selection@3:
   version "3.0.0"
   resolved "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz"
   integrity sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==
@@ -1805,7 +1713,7 @@ debounce@^1.2.1:
   resolved "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz"
   integrity sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==
 
-debug@4, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1, debug@^4.3.4:
+debug@^4.1.0, debug@^4.1.1, debug@^4.3.1, debug@^4.3.4, debug@4:
   version "4.4.3"
   resolved "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz"
   integrity sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==
@@ -1824,7 +1732,7 @@ defer-to-connect@^2.0.0:
   resolved "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz"
   integrity sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==
 
-define-data-property@^1.0.1:
+define-data-property@^1.0.1, define-data-property@^1.1.4:
   version "1.1.4"
   resolved "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz"
   integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==
@@ -1833,6 +1741,11 @@ define-data-property@^1.0.1:
     es-errors "^1.3.0"
     gopd "^1.0.1"
 
+define-lazy-prop@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz"
+  integrity sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==
+
 define-properties@^1.2.1:
   version "1.2.1"
   resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz"
@@ -1952,7 +1865,7 @@ eastasianwidth@^0.2.0:
   resolved "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz"
   integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
 
-ecdsa-sig-formatter@1.0.11, ecdsa-sig-formatter@^1.0.11:
+ecdsa-sig-formatter@^1.0.11, ecdsa-sig-formatter@1.0.11:
   version "1.0.11"
   resolved "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz"
   integrity sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==
@@ -1966,6 +1879,16 @@ ejs@^3.1.8:
   dependencies:
     jake "^10.8.5"
 
+electron-builder-squirrel-windows@24.13.3:
+  version "24.13.3"
+  resolved "https://registry.npmjs.org/electron-builder-squirrel-windows/-/electron-builder-squirrel-windows-24.13.3.tgz"
+  integrity sha512-oHkV0iogWfyK+ah9ZIvMDpei1m9ZRpdXcvde1wTpra2U8AFDNNpqJdnin5z+PM1GbQ5BoaKCWas2HSjtR0HwMg==
+  dependencies:
+    app-builder-lib "24.13.3"
+    archiver "^5.3.1"
+    builder-util "24.13.1"
+    fs-extra "^10.1.0"
+
 electron-builder@^24.13.3:
   version "24.13.3"
   resolved "https://registry.npmjs.org/electron-builder/-/electron-builder-24.13.3.tgz"
@@ -2013,7 +1936,7 @@ electron-vite@^2.1.0:
     magic-string "^0.30.10"
     picocolors "^1.0.1"
 
-electron@^28.2.0:
+electron@^28.2.0, electron@>=13.0.0:
   version "28.3.3"
   resolved "https://registry.npmjs.org/electron/-/electron-28.3.3.tgz"
   integrity sha512-ObKMLSPNhomtCOBAxFS8P2DW/4umkh72ouZUlUKzXGtYuPzgr1SYhskhFWgzAsPtUzhL2CzyV2sfbHcEW4CXqw==
@@ -2032,7 +1955,7 @@ emoji-regex@^9.2.2:
   resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz"
   integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
 
-end-of-stream@^1.1.0:
+end-of-stream@^1.1.0, end-of-stream@^1.4.1:
   version "1.4.5"
   resolved "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz"
   integrity sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==
@@ -2096,7 +2019,14 @@ es6-error@^4.1.1:
   resolved "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz"
   integrity sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==
 
-esbuild@^0.21.3, esbuild@^0.21.5:
+esbuild-register@^3.5.0:
+  version "3.6.0"
+  resolved "https://registry.npmjs.org/esbuild-register/-/esbuild-register-3.6.0.tgz"
+  integrity sha512-H2/S7Pm8a9CL1uhp9OvjwrBh5Pvx0H8qVOxNu8Wed9Y7qv56MPtq+GGM8RJpq6glYJn9Wspr8uw7l55uyinNeg==
+  dependencies:
+    debug "^4.3.4"
+
+"esbuild@^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0", esbuild@^0.21.3, esbuild@^0.21.5, "esbuild@>=0.12 <1":
   version "0.21.5"
   resolved "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz"
   integrity sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==
@@ -2135,6 +2065,11 @@ escape-string-regexp@^4.0.0:
   resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
   integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
 
+esprima@~4.0.0:
+  version "4.0.1"
+  resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz"
+  integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
+
 estree-walker@^2.0.2:
   version "2.0.2"
   resolved "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz"
@@ -2256,6 +2191,13 @@ fluent-ffmpeg@^2.1.3:
     async "^0.2.9"
     which "^1.1.1"
 
+for-each@^0.3.5:
+  version "0.3.5"
+  resolved "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz"
+  integrity sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==
+  dependencies:
+    is-callable "^1.2.7"
+
 foreground-child@^3.1.0:
   version "3.3.1"
   resolved "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz"
@@ -2287,6 +2229,11 @@ fraction.js@^5.3.4:
   resolved "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz"
   integrity sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==
 
+fs-constants@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz"
+  integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==
+
 fs-extra@^10.0.0, fs-extra@^10.1.0:
   version "10.1.0"
   resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz"
@@ -2305,7 +2252,17 @@ fs-extra@^8.1.0:
     jsonfile "^4.0.0"
     universalify "^0.1.0"
 
-fs-extra@^9.0.0, fs-extra@^9.0.1:
+fs-extra@^9.0.0:
+  version "9.1.0"
+  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz"
+  integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
+  dependencies:
+    at-least-node "^1.0.0"
+    graceful-fs "^4.2.0"
+    jsonfile "^6.0.1"
+    universalify "^2.0.0"
+
+fs-extra@^9.0.1:
   version "9.1.0"
   resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz"
   integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
@@ -2356,6 +2313,11 @@ gcp-metadata@^8.0.0:
     google-logging-utils "^1.0.0"
     json-bigint "^1.0.0"
 
+generator-function@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz"
+  integrity sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==
+
 gensync@^1.0.0-beta.2:
   version "1.0.0-beta.2"
   resolved "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz"
@@ -2366,7 +2328,7 @@ get-caller-file@^2.0.5:
   resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz"
   integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
 
-get-intrinsic@^1.2.6:
+get-intrinsic@^1.2.4, get-intrinsic@^1.2.6, get-intrinsic@^1.3.0:
   version "1.3.0"
   resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz"
   integrity sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==
@@ -2423,6 +2385,18 @@ glob@^10.3.10, glob@^10.3.7:
     package-json-from-dist "^1.0.0"
     path-scurry "^1.11.1"
 
+glob@^7.1.4:
+  version "7.2.3"
+  resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz"
+  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
+  dependencies:
+    fs.realpath "^1.0.0"
+    inflight "^1.0.4"
+    inherits "2"
+    minimatch "^3.1.1"
+    once "^1.3.0"
+    path-is-absolute "^1.0.0"
+
 glob@^7.1.6:
   version "7.2.3"
   resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz"
@@ -2435,6 +2409,18 @@ glob@^7.1.6:
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
+glob@^7.2.3:
+  version "7.2.3"
+  resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz"
+  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
+  dependencies:
+    fs.realpath "^1.0.0"
+    inflight "^1.0.4"
+    inherits "2"
+    minimatch "^3.1.1"
+    once "^1.3.0"
+    path-is-absolute "^1.0.0"
+
 global-agent@^3.0.0:
   version "3.0.0"
   resolved "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz"
@@ -2513,7 +2499,7 @@ has-flag@^4.0.0:
   resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
   integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
 
-has-property-descriptors@^1.0.0:
+has-property-descriptors@^1.0.0, has-property-descriptors@^1.0.2:
   version "1.0.2"
   resolved "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz"
   integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==
@@ -2629,11 +2615,19 @@ inflight@^1.0.4:
     once "^1.3.0"
     wrappy "1"
 
-inherits@2, inherits@^2.0.3:
+inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3, inherits@2:
   version "2.0.4"
   resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
+is-arguments@^1.0.4:
+  version "1.2.0"
+  resolved "https://registry.npmjs.org/is-arguments/-/is-arguments-1.2.0.tgz"
+  integrity sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==
+  dependencies:
+    call-bound "^1.0.2"
+    has-tostringtag "^1.0.2"
+
 is-binary-path@~2.1.0:
   version "2.1.0"
   resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz"
@@ -2641,6 +2635,11 @@ is-binary-path@~2.1.0:
   dependencies:
     binary-extensions "^2.0.0"
 
+is-callable@^1.2.7:
+  version "1.2.7"
+  resolved "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz"
+  integrity sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==
+
 is-ci@^3.0.0:
   version "3.0.1"
   resolved "https://registry.npmjs.org/is-ci/-/is-ci-3.0.1.tgz"
@@ -2655,6 +2654,11 @@ is-core-module@^2.16.1:
   dependencies:
     hasown "^2.0.2"
 
+is-docker@^2.0.0, is-docker@^2.1.1:
+  version "2.2.1"
+  resolved "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz"
+  integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
+
 is-extglob@^2.1.1:
   version "2.1.1"
   resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
@@ -2665,6 +2669,17 @@ is-fullwidth-code-point@^3.0.0:
   resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz"
   integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
 
+is-generator-function@^1.0.7:
+  version "1.1.2"
+  resolved "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz"
+  integrity sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==
+  dependencies:
+    call-bound "^1.0.4"
+    generator-function "^2.0.0"
+    get-proto "^1.0.1"
+    has-tostringtag "^1.0.2"
+    safe-regex-test "^1.1.0"
+
 is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1:
   version "4.0.3"
   resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
@@ -2682,11 +2697,40 @@ is-number@^7.0.0:
   resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
   integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
 
+is-regex@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz"
+  integrity sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==
+  dependencies:
+    call-bound "^1.0.2"
+    gopd "^1.2.0"
+    has-tostringtag "^1.0.2"
+    hasown "^2.0.2"
+
+is-typed-array@^1.1.3:
+  version "1.1.15"
+  resolved "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz"
+  integrity sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==
+  dependencies:
+    which-typed-array "^1.1.16"
+
 is-what@^5.2.0:
   version "5.5.0"
   resolved "https://registry.npmjs.org/is-what/-/is-what-5.5.0.tgz"
   integrity sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==
 
+is-wsl@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz"
+  integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
+  dependencies:
+    is-docker "^2.0.0"
+
+isarray@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz"
+  integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==
+
 isbinaryfile@^4.0.8:
   version "4.0.10"
   resolved "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.10.tgz"
@@ -2720,7 +2764,7 @@ jake@^10.8.5:
     filelist "^1.0.4"
     picocolors "^1.1.1"
 
-jiti@^1.21.7:
+jiti@^1.21.7, jiti@>=1.21.0:
   version "1.21.7"
   resolved "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz"
   integrity sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==
@@ -2737,6 +2781,11 @@ js-yaml@^4.1.0:
   dependencies:
     argparse "^2.0.1"
 
+jsdoc-type-pratt-parser@^4.0.0:
+  version "4.8.0"
+  resolved "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-4.8.0.tgz"
+  integrity sha512-iZ8Bdb84lWRuGHamRXFyML07r21pcwBrLkHEuHgEY5UbCouBwv7ECknDRKzsQIXMiqpPymqtIf8TC/shYKB5rw==
+
 jsesc@^3.0.2:
   version "3.1.0"
   resolved "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz"
@@ -2814,6 +2863,13 @@ lazy-val@^1.0.4, lazy-val@^1.0.5:
   resolved "https://registry.npmjs.org/lazy-val/-/lazy-val-1.0.5.tgz"
   integrity sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q==
 
+lazystream@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz"
+  integrity sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==
+  dependencies:
+    readable-stream "^2.0.5"
+
 lilconfig@^2.0.3:
   version "2.1.0"
   resolved "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz"
@@ -2837,25 +2893,50 @@ linkify-it@^5.0.0:
     uc.micro "^2.0.0"
 
 lodash-es@^4.17.21:
-  version "4.17.23"
-  resolved "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.23.tgz"
-  integrity sha512-kVI48u3PZr38HdYz98UmfPnXl2DXrpdctLrFLCd3kOx1xUkOmpFPx7gCWWM5MPkL/fD8zb+Ph0QzjGFs4+hHWg==
+  version "4.18.1"
+  resolved "https://registry.npmjs.org/lodash-es/-/lodash-es-4.18.1.tgz"
+  integrity sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==
 
 lodash.clonedeep@^4.5.0:
   version "4.5.0"
   resolved "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz"
   integrity sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==
 
+lodash.defaults@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz"
+  integrity sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==
+
+lodash.difference@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.npmjs.org/lodash.difference/-/lodash.difference-4.5.0.tgz"
+  integrity sha512-dS2j+W26TQ7taQBGN8Lbbq04ssV3emRw4NY58WErlTO29pIqS0HmoT5aJ9+TUQ1N3G+JOZSji4eugsWwGp9yPA==
+
+lodash.flatten@^4.4.0:
+  version "4.4.0"
+  resolved "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz"
+  integrity sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==
+
 lodash.isequal@^4.5.0:
   version "4.5.0"
   resolved "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz"
   integrity sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==
 
+lodash.isplainobject@^4.0.6:
+  version "4.0.6"
+  resolved "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz"
+  integrity sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==
+
 lodash.memoize@^4.1.2:
   version "4.1.2"
   resolved "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz"
   integrity sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==
 
+lodash.union@^4.6.0:
+  version "4.6.0"
+  resolved "https://registry.npmjs.org/lodash.union/-/lodash.union-4.6.0.tgz"
+  integrity sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw==
+
 lodash.uniq@^4.5.0:
   version "4.5.0"
   resolved "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz"
@@ -2983,14 +3064,35 @@ minimatch@^3.0.4, minimatch@^3.1.1:
   dependencies:
     brace-expansion "^1.1.7"
 
-minimatch@^5.0.1, minimatch@^5.1.1:
+minimatch@^5.0.1:
+  version "5.1.6"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz"
+  integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==
+  dependencies:
+    brace-expansion "^2.0.1"
+
+minimatch@^5.1.0:
+  version "5.1.9"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz"
+  integrity sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==
+  dependencies:
+    brace-expansion "^2.0.1"
+
+minimatch@^5.1.1:
   version "5.1.6"
   resolved "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz"
   integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==
   dependencies:
     brace-expansion "^2.0.1"
 
-minimatch@^9.0.3, minimatch@^9.0.4:
+minimatch@^9.0.3:
+  version "9.0.5"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz"
+  integrity sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==
+  dependencies:
+    brace-expansion "^2.0.1"
+
+minimatch@^9.0.4:
   version "9.0.5"
   resolved "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz"
   integrity sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==
@@ -3009,12 +3111,17 @@ minipass@^3.0.0:
   dependencies:
     yallist "^4.0.0"
 
+"minipass@^5.0.0 || ^6.0.2 || ^7.0.0":
+  version "7.1.2"
+  resolved "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz"
+  integrity sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==
+
 minipass@^5.0.0:
   version "5.0.0"
   resolved "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz"
   integrity sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==
 
-"minipass@^5.0.0 || ^6.0.2 || ^7.0.0", minipass@^7.1.2:
+minipass@^7.1.2:
   version "7.1.2"
   resolved "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz"
   integrity sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==
@@ -3124,6 +3231,15 @@ once@^1.3.0, once@^1.3.1, once@^1.4.0:
   dependencies:
     wrappy "1"
 
+open@^8.0.4:
+  version "8.4.2"
+  resolved "https://registry.npmjs.org/open/-/open-8.4.2.tgz"
+  integrity sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==
+  dependencies:
+    define-lazy-prop "^2.0.0"
+    is-docker "^2.1.1"
+    is-wsl "^2.2.0"
+
 p-cancelable@^2.0.0:
   version "2.1.1"
   resolved "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz"
@@ -3209,7 +3325,7 @@ picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1:
   resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
   integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
 
-picomatch@^4.0.3:
+"picomatch@^3 || ^4", picomatch@^4.0.3:
   version "4.0.3"
   resolved "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz"
   integrity sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==
@@ -3219,10 +3335,10 @@ pify@^2.3.0:
   resolved "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz"
   integrity sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==
 
-pilotui@^1.28.1:
-  version "1.28.1"
-  resolved "https://registry.npmjs.org/pilotui/-/pilotui-1.28.1.tgz"
-  integrity sha512-S9MJt00HEBUUBk775bOSTWkkkVjjce7lFsvOC+q0ovqfAo3/x0vGHkSUyzNrj2nelAyoZQQuCYYsA1Pn20Ylow==
+pilotui@^1.29.1:
+  version "1.29.1"
+  resolved "https://registry.npmjs.org/pilotui/-/pilotui-1.29.1.tgz"
+  integrity sha512-DwAv34kB1K+17OR/bsJly+yE/I19mHkbQstbaThbmiu4vA/o2wwbj6dPQFbpgwkoJEFFIY7ojzCt9cy4evcfpw==
   dependencies:
     "@headlessui/vue" "^1.7.23"
     "@storybook/builder-vite" "^8.4.5"
@@ -3265,6 +3381,11 @@ plist@^3.0.4, plist@^3.0.5:
     base64-js "^1.5.1"
     xmlbuilder "^15.1.1"
 
+possible-typed-array-names@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz"
+  integrity sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==
+
 postcss-calc@^8.2.3:
   version "8.2.4"
   resolved "https://registry.npmjs.org/postcss-calc/-/postcss-calc-8.2.4.tgz"
@@ -3487,14 +3608,6 @@ postcss-reduce-transforms@^5.1.0:
   dependencies:
     postcss-value-parser "^4.2.0"
 
-postcss-selector-parser@6.0.10:
-  version "6.0.10"
-  resolved "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz"
-  integrity sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==
-  dependencies:
-    cssesc "^3.0.0"
-    util-deprecate "^1.0.2"
-
 postcss-selector-parser@^6.0.4, postcss-selector-parser@^6.0.5, postcss-selector-parser@^6.0.9, postcss-selector-parser@^6.1.1, postcss-selector-parser@^6.1.2:
   version "6.1.2"
   resolved "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz"
@@ -3503,6 +3616,14 @@ postcss-selector-parser@^6.0.4, postcss-selector-parser@^6.0.5, postcss-selector
     cssesc "^3.0.0"
     util-deprecate "^1.0.2"
 
+postcss-selector-parser@6.0.10:
+  version "6.0.10"
+  resolved "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz"
+  integrity sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==
+  dependencies:
+    cssesc "^3.0.0"
+    util-deprecate "^1.0.2"
+
 postcss-svgo@^5.1.0:
   version "5.1.0"
   resolved "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-5.1.0.tgz"
@@ -3536,7 +3657,7 @@ postcss@^7.0.1:
     picocolors "^0.2.1"
     source-map "^0.6.1"
 
-postcss@^8.4.38, postcss@^8.4.43, postcss@^8.4.47, postcss@^8.5.6:
+postcss@^8.0.0, postcss@^8.0.9, postcss@^8.1.0, postcss@^8.2.14, postcss@^8.2.15, postcss@^8.2.2, postcss@^8.4.21, postcss@^8.4.38, postcss@^8.4.43, postcss@^8.4.47, postcss@^8.5.6, postcss@>=8.0.9:
   version "8.5.6"
   resolved "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz"
   integrity sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==
@@ -3545,6 +3666,16 @@ postcss@^8.4.38, postcss@^8.4.43, postcss@^8.4.47, postcss@^8.5.6:
     picocolors "^1.1.1"
     source-map-js "^1.2.1"
 
+process-nextick-args@~2.0.0:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz"
+  integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
+
+process@^0.11.10:
+  version "0.11.10"
+  resolved "https://registry.npmjs.org/process/-/process-0.11.10.tgz"
+  integrity sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==
+
 progress@^2.0.3:
   version "2.0.3"
   resolved "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz"
@@ -3642,7 +3773,33 @@ read-config-file@6.3.2:
     json5 "^2.2.0"
     lazy-val "^1.0.4"
 
-readable-stream@^3.0.2:
+readable-stream@^2.0.0:
+  version "2.3.8"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz"
+  integrity sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==
+  dependencies:
+    core-util-is "~1.0.0"
+    inherits "~2.0.3"
+    isarray "~1.0.0"
+    process-nextick-args "~2.0.0"
+    safe-buffer "~5.1.1"
+    string_decoder "~1.1.1"
+    util-deprecate "~1.0.1"
+
+readable-stream@^2.0.5:
+  version "2.3.8"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz"
+  integrity sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==
+  dependencies:
+    core-util-is "~1.0.0"
+    inherits "~2.0.3"
+    isarray "~1.0.0"
+    process-nextick-args "~2.0.0"
+    safe-buffer "~5.1.1"
+    string_decoder "~1.1.1"
+    util-deprecate "~1.0.1"
+
+readable-stream@^3.0.2, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.6.0:
   version "3.6.2"
   resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz"
   integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==
@@ -3651,6 +3808,13 @@ readable-stream@^3.0.2:
     string_decoder "^1.1.1"
     util-deprecate "^1.0.1"
 
+readdir-glob@^1.1.2:
+  version "1.1.3"
+  resolved "https://registry.npmjs.org/readdir-glob/-/readdir-glob-1.1.3.tgz"
+  integrity sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==
+  dependencies:
+    minimatch "^5.1.0"
+
 readdirp@~3.6.0:
   version "3.6.0"
   resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz"
@@ -3658,6 +3822,17 @@ readdirp@~3.6.0:
   dependencies:
     picomatch "^2.2.1"
 
+recast@^0.23.5:
+  version "0.23.12"
+  resolved "https://registry.npmjs.org/recast/-/recast-0.23.12.tgz"
+  integrity sha512-dEWRjcINDu/F4l2dYx57ugBtD7HV9KXESyxhzw/MqWLeglJrsjJKqACPyUPg+6AF8mIgm+Zi0dZ3ACoIg+QtpA==
+  dependencies:
+    ast-types "^0.16.1"
+    esprima "~4.0.0"
+    source-map "~0.6.1"
+    tiny-invariant "^1.3.3"
+    tslib "^2.0.1"
+
 require-directory@^2.1.1:
   version "2.1.1"
   resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz"
@@ -3764,6 +3939,20 @@ safe-buffer@^5.0.1, safe-buffer@~5.2.0:
   resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz"
   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
 
+safe-buffer@~5.1.0, safe-buffer@~5.1.1:
+  version "5.1.2"
+  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz"
+  integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
+
+safe-regex-test@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz"
+  integrity sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==
+  dependencies:
+    call-bound "^1.0.2"
+    es-errors "^1.3.0"
+    is-regex "^1.2.1"
+
 "safer-buffer@>= 2.1.2 < 3.0.0":
   version "2.1.2"
   resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz"
@@ -3776,10 +3965,10 @@ sanitize-filename@^1.6.3:
   dependencies:
     truncate-utf8-bytes "^1.0.0"
 
-sax@^1.2.4:
-  version "1.4.4"
-  resolved "https://registry.npmjs.org/sax/-/sax-1.4.4.tgz"
-  integrity sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw==
+sax@^1.2.4, sax@^1.5.0:
+  version "1.6.0"
+  resolved "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz"
+  integrity sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==
 
 semver-compare@^1.0.0:
   version "1.0.0"
@@ -3791,11 +3980,26 @@ semver@^6.2.0, semver@^6.3.1:
   resolved "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz"
   integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
 
-semver@^7.3.2, semver@^7.3.8, semver@^7.5.3:
+semver@^7.3.2:
+  version "7.7.4"
+  resolved "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz"
+  integrity sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==
+
+semver@^7.3.8:
+  version "7.7.4"
+  resolved "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz"
+  integrity sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==
+
+semver@^7.5.3:
   version "7.7.4"
   resolved "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz"
   integrity sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==
 
+semver@^7.6.2:
+  version "7.8.5"
+  resolved "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz"
+  integrity sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==
+
 serialize-error@^7.0.1:
   version "7.0.1"
   resolved "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz"
@@ -3803,6 +4007,18 @@ serialize-error@^7.0.1:
   dependencies:
     type-fest "^0.13.1"
 
+set-function-length@^1.2.2:
+  version "1.2.2"
+  resolved "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz"
+  integrity sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==
+  dependencies:
+    define-data-property "^1.1.4"
+    es-errors "^1.3.0"
+    function-bind "^1.1.2"
+    get-intrinsic "^1.2.4"
+    gopd "^1.0.1"
+    has-property-descriptors "^1.0.2"
+
 shebang-command@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
@@ -3854,7 +4070,7 @@ source-map-support@^0.5.19:
     buffer-from "^1.0.0"
     source-map "^0.6.0"
 
-source-map@^0.6.0, source-map@^0.6.1:
+source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1:
   version "0.6.1"
   resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
@@ -3879,6 +4095,27 @@ stat-mode@^1.0.0:
   resolved "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz"
   integrity sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg==
 
+"storybook@^8.2.0 || ^8.3.0-0 || ^8.4.0-0 || ^8.5.0-0 || ^8.6.0-0", storybook@^8.6.18:
+  version "8.6.18"
+  resolved "https://registry.npmjs.org/storybook/-/storybook-8.6.18.tgz"
+  integrity sha512-p8seiSI6FiVY6P3V0pG+5v7c8pDMehMAFRWEhG5XqIBSQszzOjDnW2rNvm3odoLKfo3V3P6Cs6Hv9ILzymULyQ==
+  dependencies:
+    "@storybook/core" "8.6.18"
+
+string_decoder@^1.1.1:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz"
+  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
+  dependencies:
+    safe-buffer "~5.2.0"
+
+string_decoder@~1.1.1:
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz"
+  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
+  dependencies:
+    safe-buffer "~5.1.0"
+
 "string-width-cjs@npm:string-width@^4.2.0":
   version "4.2.3"
   resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
@@ -3906,13 +4143,6 @@ string-width@^5.0.1, string-width@^5.1.2:
     emoji-regex "^9.2.2"
     strip-ansi "^7.0.1"
 
-string_decoder@^1.1.1:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz"
-  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
-  dependencies:
-    safe-buffer "~5.2.0"
-
 "strip-ansi-cjs@npm:strip-ansi@^6.0.1":
   version "6.0.1"
   resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
@@ -3982,24 +4212,24 @@ supports-preserve-symlinks-flag@^1.0.0:
   integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
 
 svgo@^2.7.0:
-  version "2.8.0"
-  resolved "https://registry.npmjs.org/svgo/-/svgo-2.8.0.tgz"
-  integrity sha512-+N/Q9kV1+F+UeWYoSiULYo4xYSDQlTgb+ayMobAXPwMnLvop7oxKMo9OzIrX5x3eS4L4f2UHhc9axXwY8DpChg==
+  version "2.8.3"
+  resolved "https://registry.npmjs.org/svgo/-/svgo-2.8.3.tgz"
+  integrity sha512-5EZD0pafXX6PphdwOGCiVLDSaV1xyuQao2blHajHLsPxr07q4mmEjdtXEWgG07ae2mIz8Ex2CDXNCTiXhy3Khw==
   dependencies:
-    "@trysound/sax" "0.2.0"
     commander "^7.2.0"
     css-select "^4.1.3"
     css-tree "^1.1.3"
     csso "^4.2.0"
     picocolors "^1.0.0"
+    sax "^1.5.0"
     stable "^0.1.8"
 
 sweetalert2@^11.15.3:
-  version "11.26.18"
-  resolved "https://registry.npmjs.org/sweetalert2/-/sweetalert2-11.26.18.tgz"
-  integrity sha512-3O5feBqV+hTIOwCRKGuZGHosjiuBAKP/vpBl6vKFZeVYfCUGdXqXuuidn6YXHan3f6e62UdmnjwJBt8UtDVBhg==
+  version "11.26.25"
+  resolved "https://registry.npmjs.org/sweetalert2/-/sweetalert2-11.26.25.tgz"
+  integrity sha512-+hunCOJdJ6FLj04T9YSLvvZXRjsvIkTeTKP2e4VF8CaBias961BTnWiSFAy7F/CM5eq3QK2Rraoc5Gzftslvkg==
 
-tailwindcss@^3.4.3:
+tailwindcss@^3.4.3, "tailwindcss@>=3.0.0 || insiders || >=4.0.0-alpha.20 || >=4.0.0-beta.1":
   version "3.4.19"
   resolved "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz"
   integrity sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==
@@ -4027,6 +4257,17 @@ tailwindcss@^3.4.3:
     resolve "^1.22.8"
     sucrase "^3.35.0"
 
+tar-stream@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz"
+  integrity sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==
+  dependencies:
+    bl "^4.0.3"
+    end-of-stream "^1.4.1"
+    fs-constants "^1.0.0"
+    inherits "^2.0.3"
+    readable-stream "^3.1.1"
+
 tar@^6.1.12:
   version "6.2.1"
   resolved "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz"
@@ -4061,6 +4302,11 @@ thenify-all@^1.0.0:
   dependencies:
     any-promise "^1.0.0"
 
+tiny-invariant@^1.3.3:
+  version "1.3.3"
+  resolved "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz"
+  integrity sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==
+
 tinyglobby@^0.2.11:
   version "0.2.15"
   resolved "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz"
@@ -4096,15 +4342,20 @@ truncate-utf8-bytes@^1.0.0:
     utf8-byte-length "^1.0.1"
 
 ts-dedent@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.2.0.tgz"
-  integrity sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==
+  version "2.3.0"
+  resolved "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.3.0.tgz"
+  integrity sha512-JfJeIHke7y2egdGGgRAvpCwYFUsHlM2gPcrVOxFkznt/4uzQ7HFmvE63iFHVLBJNDuyDOQgijDK/tXH/f6Msjg==
 
 ts-interface-checker@^0.1.9:
   version "0.1.13"
   resolved "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz"
   integrity sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==
 
+tslib@^2.0.1:
+  version "2.8.1"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz"
+  integrity sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==
+
 type-fest@^0.13.1:
   version "0.13.1"
   resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz"
@@ -4115,7 +4366,7 @@ typedarray@^0.0.6:
   resolved "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz"
   integrity sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==
 
-typescript@^5.3.3, typescript@^5.4.2:
+typescript@*, typescript@^5.3.3, typescript@^5.4.2, typescript@>=4.4.4, typescript@>=4.5.0, typescript@>=5.0.0:
   version "5.9.3"
   resolved "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz"
   integrity sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==
@@ -4173,11 +4424,22 @@ utf8-byte-length@^1.0.1:
   resolved "https://registry.npmjs.org/utf8-byte-length/-/utf8-byte-length-1.0.5.tgz"
   integrity sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA==
 
-util-deprecate@^1.0.1, util-deprecate@^1.0.2:
+util-deprecate@^1.0.1, util-deprecate@^1.0.2, util-deprecate@~1.0.1:
   version "1.0.2"
   resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz"
   integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
 
+util@^0.12.5:
+  version "0.12.5"
+  resolved "https://registry.npmjs.org/util/-/util-0.12.5.tgz"
+  integrity sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==
+  dependencies:
+    inherits "^2.0.3"
+    is-arguments "^1.0.4"
+    is-generator-function "^1.0.7"
+    is-typed-array "^1.1.3"
+    which-typed-array "^1.1.2"
+
 uuid@^13.0.0:
   version "13.0.0"
   resolved "https://registry.npmjs.org/uuid/-/uuid-13.0.0.tgz"
@@ -4192,7 +4454,7 @@ verror@^1.10.0:
     core-util-is "1.0.2"
     extsprintf "^1.2.0"
 
-vite@^5.1.6:
+"vite@^4.0.0 || ^5.0.0", "vite@^4.0.0 || ^5.0.0 || ^6.0.0", "vite@^5.0.0 || ^6.0.0", vite@^5.1.6:
   version "5.4.21"
   resolved "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz"
   integrity sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==
@@ -4213,7 +4475,7 @@ vue-collapsed@^1.3.4:
   resolved "https://registry.npmjs.org/vue-collapsed/-/vue-collapsed-1.3.5.tgz"
   integrity sha512-U6wCa4mFpaX2Fr9BWtGNPte3SAgtpk1NjeS/NRLHDHu2fDs3/MQ3W13pvWXy5BGbtz14HxzSq6efC9WrHblozQ==
 
-vue-demi@*, vue-demi@>=0.14.8, vue-demi@^0.14.10:
+vue-demi@*, vue-demi@^0.14.10, vue-demi@>=0.14.8:
   version "0.14.10"
   resolved "https://registry.npmjs.org/vue-demi/-/vue-demi-0.14.10.tgz"
   integrity sha512-nMZBOwuzabUO0nLgIcc6rycZEebF6eeUfaiQx9+WSk8e29IbLvPU9feI6tqW4kTo3hvoYAJkMh8n8D0fuISphg==
@@ -4233,6 +4495,17 @@ vue-tsc@^2.0.6:
     "@volar/typescript" "2.4.15"
     "@vue/language-core" "2.2.12"
 
+"vue@^2.7.0 || ^3.0.0", "vue@^2.7.0 || ^3.5.11", "vue@^3.0.0-0 || ^2.6.0", vue@^3.2.0, vue@^3.2.20, vue@^3.2.25, vue@^3.3.0, vue@^3.4.21, vue@^3.5.0, vue@^3.5.11, vue@^3.5.12, "vue@>=2.7 || >=3", vue@3.5.28:
+  version "3.5.28"
+  resolved "https://registry.npmjs.org/vue/-/vue-3.5.28.tgz"
+  integrity sha512-BRdrNfeoccSoIZeIhyPBfvWSLFP4q8J3u8Ju8Ug5vu3LdD+yTM13Sg4sKtljxozbnuMu1NB1X5HBHRYUzFocKg==
+  dependencies:
+    "@vue/compiler-dom" "3.5.28"
+    "@vue/compiler-sfc" "3.5.28"
+    "@vue/runtime-dom" "3.5.28"
+    "@vue/server-renderer" "3.5.28"
+    "@vue/shared" "3.5.28"
+
 vue3-perfect-scrollbar@^1.6.0:
   version "1.6.1"
   resolved "https://registry.npmjs.org/vue3-perfect-scrollbar/-/vue3-perfect-scrollbar-1.6.1.tgz"
@@ -4250,17 +4523,6 @@ vue3-popper@^1.5.0:
     "@popperjs/core" "^2.9.2"
     debounce "^1.2.1"
 
-vue@^3.4.21, vue@^3.5.12:
-  version "3.5.28"
-  resolved "https://registry.npmjs.org/vue/-/vue-3.5.28.tgz"
-  integrity sha512-BRdrNfeoccSoIZeIhyPBfvWSLFP4q8J3u8Ju8Ug5vu3LdD+yTM13Sg4sKtljxozbnuMu1NB1X5HBHRYUzFocKg==
-  dependencies:
-    "@vue/compiler-dom" "3.5.28"
-    "@vue/compiler-sfc" "3.5.28"
-    "@vue/runtime-dom" "3.5.28"
-    "@vue/server-renderer" "3.5.28"
-    "@vue/shared" "3.5.28"
-
 web-streams-polyfill@^3.0.3:
   version "3.3.3"
   resolved "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz"
@@ -4271,6 +4533,19 @@ webpack-virtual-modules@^0.6.2:
   resolved "https://registry.npmjs.org/webpack-virtual-modules/-/webpack-virtual-modules-0.6.2.tgz"
   integrity sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ==
 
+which-typed-array@^1.1.16, which-typed-array@^1.1.2:
+  version "1.1.22"
+  resolved "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.22.tgz"
+  integrity sha512-fvO4ExWMFsqyhG3AiPAObMuY1lxaqgYcxbc49CNdWDDECOJNgQyvsOWVwbZc+qf3rzRtxojBK+CMEv0Ld5CYpw==
+  dependencies:
+    available-typed-arrays "^1.0.7"
+    call-bind "^1.0.9"
+    call-bound "^1.0.4"
+    for-each "^0.3.5"
+    get-proto "^1.0.1"
+    gopd "^1.2.0"
+    has-tostringtag "^1.0.2"
+
 which@^1.1.1:
   version "1.3.1"
   resolved "https://registry.npmjs.org/which/-/which-1.3.1.tgz"
@@ -4317,12 +4592,12 @@ wrappy@1:
   resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
   integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
 
-ws@^8.18.0:
+ws@^8.18.0, ws@^8.2.3:
   version "8.19.0"
   resolved "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz"
   integrity sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==
 
-xmlbuilder@>=11.0.1, xmlbuilder@^15.1.1:
+xmlbuilder@^15.1.1, xmlbuilder@>=11.0.1:
   version "15.1.1"
   resolved "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz"
   integrity sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==
@@ -4347,6 +4622,11 @@ yaml@^1.10.2:
   resolved "https://registry.npmjs.org/yaml/-/yaml-1.10.3.tgz"
   integrity sha512-vIYeF1u3CjlhAFekPPAk2h/Kv4T3mAkMox5OymRiJQB0spDP10LHvt+K7G9Ny6NuuMAb25/6n1qyUjAcGNf/AA==
 
+yaml@^2.4.2:
+  version "2.8.3"
+  resolved "https://registry.npmjs.org/yaml/-/yaml-2.8.3.tgz"
+  integrity sha512-AvbaCLOO2Otw/lW5bmh9d/WEdcDFdQp2Z2ZUH3pX9U2ihyUY0nvLv7J6TrWowklRGPYbB/IuIMfYgxaCPg5Bpg==
+
 yargs-parser@^21.1.1:
   version "21.1.1"
   resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz"
@@ -4377,3 +4657,12 @@ ytdlp-nodejs@^3.4.4:
   version "3.4.4"
   resolved "https://registry.npmjs.org/ytdlp-nodejs/-/ytdlp-nodejs-3.4.4.tgz"
   integrity sha512-PR2nQOtyOzSuSQpWf6SHD97d6qlcfY2y6CVCeYnuDacYDc1YzNLXYiqAyIpFWk13UUrtQN+XD35h5DERli3SXQ==
+
+zip-stream@^4.1.0:
+  version "4.1.1"
+  resolved "https://registry.npmjs.org/zip-stream/-/zip-stream-4.1.1.tgz"
+  integrity sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==
+  dependencies:
+    archiver-utils "^3.0.4"
+    compress-commons "^4.1.2"
+    readable-stream "^3.6.0"