diff --git a/README.md b/README.md
index 5158a6c8..bcd63a47 100644
--- a/README.md
+++ b/README.md
@@ -174,6 +174,7 @@ dapi media grab clip.mp4 -t 0 12 45                      # decode frames to PNGs
 dapi media filmstrip clip.mp4                            # grid of video frames
 dapi media waveform track.mp3                            # audio waveform, silence flagged
 dapi media transcribe interview.wav                      # timed, word-level transcript
+dapi media autocut interview.mp4 --jsx                 # keep-ranges + optional JSX sequence
 dapi media listen interview.mp4 -p "what is said in the intro?"   # ask a multimodal model
 dapi capture intro -t 0 2 4                              # the frames a render would produce, by scene id
 ```
@@ -184,7 +185,7 @@ dapi capture intro -t 0 2 4                              # the frames a render w
 | `dapi context` | Summary of app state |
 | `dapi capture` | Render frames of a scene, as an export would, to a labelled contact sheet or one PNG per position |
 | `dapi check` | Check a node's subtree for structural mistakes (black-frame gaps, never-visible nodes, failed sources) and report subtree stats |
-| `dapi media …` | Inspect a file by id or path: `probe`, `grab`, `filmstrip`, `waveform`, `transcribe`, `listen` |
+| `dapi media …` | Inspect a file by id or path: `probe`, `grab`, `filmstrip`, `waveform`, `transcribe`, `autocut`, `listen` |
 | `dapi models` / `dapi voices` / `dapi fonts` | Discover generation models, speech voices, local fonts |
 | `dapi screenshot` / `dapi logs` | The app itself: capture the window, read recent console output |
 | `dapi fetch` | Download a video from yt/tt/ig |
diff --git a/apps/cli/package.json b/apps/cli/package.json
index 06ea360d..3055b9c3 100644
--- a/apps/cli/package.json
+++ b/apps/cli/package.json
@@ -18,6 +18,7 @@
   },
   "dependencies": {
     "@babel/core": "^7.29.7",
+    "@diffusionstudio/runtime": "*",
     "@trpc/client": "^11.18.0",
     "@trpc/server": "^11.18.0",
     "@babel/preset-typescript": "^7.27.1",
diff --git a/apps/cli/src/index.ts b/apps/cli/src/index.ts
index c869ab38..d4b9f138 100644
--- a/apps/cli/src/index.ts
+++ b/apps/cli/src/index.ts
@@ -15,6 +15,7 @@ import { editor, errnoCode, GENERATE_TIMEOUT_MS, waitForCliSocket } from "./cli-
 import { listLocalFonts } from "./fonts";
 import { buildIssueBody, createIssue } from "./report";
 import { fetchVideo } from "./ytdlp";
+import { computeAutocut, formatAutocutJsx, type Transcript } from "@diffusionstudio/runtime/media";
 import { MAX_FRAMES_PER_SHEET } from "./protocol";
 import type { AssetRef, FrameQuality, LogEntry, LogLevel, TimecodedImage } from "./protocol";
 
@@ -282,6 +283,117 @@ async function mediaWaveform(ref: string, opts: MediaPreviewOptions): Promise<vo
   }
 }
 
+type MediaAutocutOptions = {
+  silenceMin?: string;
+  pad?: string;
+  lang?: string;
+  jsx?: boolean;
+  start?: string;
+  end?: string;
+};
+
+async function mediaAutocut(ref: string, opts: MediaAutocutOptions): Promise<void> {
+  const { start, end } = parsePreviewWindow(opts);
+  const target = resolveAssetRef(ref);
+
+  let silenceMin = 0.4;
+  if (opts.silenceMin !== undefined) {
+    silenceMin = Number(opts.silenceMin);
+    if (!Number.isFinite(silenceMin) || silenceMin < 0) {
+      console.error(`--silence-min must be a non-negative number (got "${opts.silenceMin}")`);
+      process.exit(1);
+    }
+  }
+
+  let pad = 0.05;
+  if (opts.pad !== undefined) {
+    pad = Number(opts.pad);
+    if (!Number.isFinite(pad) || pad < 0) {
+      console.error(`--pad must be a non-negative number (got "${opts.pad}")`);
+      process.exit(1);
+    }
+  }
+
+  const lang = opts.lang ?? "all";
+  if (lang !== "en" && lang !== "es" && lang !== "all") {
+    console.error(`--lang must be one of en, es, all (got "${opts.lang}")`);
+    process.exit(1);
+  }
+
+  type ProbeResult = { duration?: number; width?: number; height?: number; type?: string };
+
+  const stopProbe = startSpinner("Probing asset");
+  let probe: ProbeResult;
+  try {
+    probe = (await editor.media.probe.query(target)) as ProbeResult;
+    stopProbe();
+    if (typeof probe.duration !== "number" || !Number.isFinite(probe.duration) || probe.duration <= 0) {
+      console.error("Could not determine asset duration from probe metadata.");
+      process.exit(1);
+    }
+  } catch (e) {
+    stopProbe();
+    handleSocketError(e);
+  }
+
+  const duration = probe.duration!;
+
+  const stopWave = startSpinner("Analyzing silences");
+  let silences: Array<{ start: number; end: number }>;
+  try {
+    const { silences: spans } = await editor.media.waveform.query({
+      ...target,
+      start,
+      end,
+      scale: 0.25,
+    });
+    stopWave();
+    silences = spans;
+  } catch (e) {
+    stopWave();
+    handleSocketError(e);
+  }
+
+  const stopTranscribe = startSpinner("Transcribing asset");
+  let transcript: Transcript;
+  try {
+    transcript = await editor.media.transcribe.query(target, GENERATE);
+    stopTranscribe();
+  } catch (e) {
+    stopTranscribe();
+    const code = errnoCode(e);
+    if (code === "ENOENT" || code === "ECONNREFUSED") handleSocketError(e);
+    const msg = e instanceof Error ? e.message : String(e);
+    if (/no speech detected/i.test(msg)) {
+      console.error("No speech detected; continuing with silence-only cuts.");
+    } else {
+      console.error(`${msg}; continuing with silence-only cuts.`);
+    }
+    transcript = { segments: [] };
+  }
+
+  const result = computeAutocut(
+    {
+      duration,
+      silences,
+      transcript,
+      ...(start !== undefined || end !== undefined ? { window: { start: start ?? 0, end: end ?? duration } } : {}),
+    },
+    { silenceMin, pad, lang: lang as "en" | "es" | "all" },
+  );
+
+  const output: Record<string, unknown> = { ...result };
+  if (opts.jsx) {
+    output.jsx = formatAutocutJsx(ref, result.keep, {
+      width: probe.width,
+      height: probe.height,
+      kind: probe.type === "AUDIO" ? "audio" : "video",
+    });
+  }
+
+  console.log(JSON.stringify(output));
+}
+
 type CaptureOptions = { time?: string[]; output?: string; separate?: boolean; perSheet?: string };
 
 async function captureNode(id: string, opts: CaptureOptions): Promise<void> {
@@ -700,6 +812,20 @@ media
   .option("-o, --output <path>", "write the PNG here instead of a temp file")
   .action((ref: string, opts: MediaPreviewOptions) => mediaWaveform(ref, opts));
 
+media
+  .command("autocut")
+  .description(
+    `Propose keep-ranges for a jump-cut edit by composing waveform silence detection with a timed transcript: drops silent stretches, immediate word repeats (stutters), and vocal fillers (um/uh/eh/em) plus safe phrases (you know, i mean, o sea). Does not re-encode — returns second ranges to trim with \`sourceIn\`/\`sourceOut\`, and optionally a JSX \`<sequence>\` of back-to-back clips. Uses cloud STT when signed in; continues with silence-only cuts when transcription is unavailable or no speech is detected.`,
+  )
+  .argument("<path>", "local video or audio file path, or library path")
+  .option("-s, --start <time>", `start of the window to analyze — seconds, "45f" frames, or "MM:SS" (default: 0)`)
+  .option("-e, --end <time>", `end of the window to analyze — seconds, "45f" frames, or "MM:SS" (default: asset duration)`)
+  .option("--silence-min <seconds>", "drop silences at least this long (default: 0.4; waveform amplitude threshold is fixed in the app)")
+  .option("--pad <seconds>", "keep this much audio on each side of a cut so speech does not clip (default: 0.05)")
+  .option("--lang <code>", "filler vocabulary: en, es, or all (default: all)")
+  .option("--jsx", "include a JSX <sequence> string using sourceIn/sourceOut for each kept span")
+  .action((ref: string, opts: MediaAutocutOptions) => mediaAutocut(ref, opts));
+
 media
   .command("listen")
   .description(
diff --git a/apps/web/src/components/sidebar-left/project-menu/object-menu.tsx b/apps/web/src/components/sidebar-left/project-menu/object-menu.tsx
index e53305a7..2ce0e400 100644
--- a/apps/web/src/components/sidebar-left/project-menu/object-menu.tsx
+++ b/apps/web/src/components/sidebar-left/project-menu/object-menu.tsx
@@ -22,6 +22,16 @@ import {
   wrapSelectionInScene,
   wrapSelectionInSequence,
 } from "@/engine";
+import {
+  analyzeClipForAutocut,
+  applyAutocutToClip,
+  autocutWouldChange,
+  isAutocutClip,
+  planAutocutTimeline,
+  timelineStartSeconds,
+} from "@/engine/autocut";
+import { getEditHistory } from "@/engine/history";
+import { toast } from "somoto";
 
 export function ObjectMenu() {
   const world = useWorld();
@@ -186,6 +196,51 @@ export function ObjectMenu() {
 }
 
 export function ObjectAiMenu() {
+  const world = useWorld();
+  const { nodes } = useSelection();
+
+  const canRemoveSilences = () => {
+    const eligible = nodes().filter((entity) => isAutocutClip(world, entity));
+    return eligible.length === 1;
+  };
+
+  const removeSilences = async () => {
+    const eligible = nodes().filter((entity) => isAutocutClip(world, entity));
+    const entity = eligible.length === 1 ? eligible[0] : null;
+    if (!entity) return;
+
+    const history = getEditHistory(world);
+
+    try {
+      const result = await analyzeClipForAutocut(world, entity);
+      if (!autocutWouldChange(result.removed)) {
+        toast("Nothing to cut", { description: "No silences, fillers, or stutters were found in this clip." });
+        return;
+      }
+
+      const specs = planAutocutTimeline(result.keep, timelineStartSeconds(world, entity));
+      if (specs.length === 0) {
+        toast("Nothing to cut", { description: "Remove silences would remove the entire clip." });
+        return;
+      }
+
+      history.beginGesture();
+      try {
+        applyAutocutToClip(world, entity, specs);
+      } finally {
+        history.endGesture();
+      }
+
+      toast("Silences removed", {
+        description: `${specs.length} clip${specs.length === 1 ? "" : "s"} on the timeline.`,
+      });
+    } catch (err) {
+      toast.error("Remove silences failed", {
+        description: err instanceof Error ? err.message : String(err),
+      });
+    }
+  };
+
   return (
     <>
       <DropdownMenuGroup>
@@ -196,7 +251,9 @@ export function ObjectAiMenu() {
       <DropdownMenuSeparator />
 
       <DropdownMenuGroup>
-        <DropdownMenuItem>Remove silences</DropdownMenuItem>
+        <DropdownMenuItem disabled={!canRemoveSilences()} onSelect={() => void removeSilences()}>
+          Remove silences
+        </DropdownMenuItem>
         <DropdownMenuItem>Lip sync</DropdownMenuItem>
       </DropdownMenuGroup>
     </>
diff --git a/apps/web/src/engine/autocut.tsx b/apps/web/src/engine/autocut.tsx
new file mode 100644
index 00000000..5afdb24d
--- /dev/null
+++ b/apps/web/src/engine/autocut.tsx
@@ -0,0 +1,247 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Remove silences on a selected timeline clip: analyze silences + transcript,
+ * then replace the clip with a row of trimmed copies in a sequence.
+ */
+
+import { Audio, Sequence, Video, authoredElement, authoredTree, renderAuthored } from "@diffusionstudio/reconciler";
+import type { AuthoredTree } from "@diffusionstudio/reconciler";
+import {
+  FrameRate,
+  autocutWouldChange,
+  computeAutocut,
+  findGeometryAsset,
+  framesToSeconds,
+  getEntityChildren,
+  getLibrary,
+  getNextName,
+  getParentEntity,
+  getSourceWindow,
+  isGroup,
+  isSequence,
+  planAutocutTimeline,
+  transcodeForTranscription,
+  waveformAsset,
+  type AutocutClipSpec,
+  type AutocutResult,
+  type Transcript,
+} from "@diffusionstudio/runtime";
+import { trpc } from "@/lib/trpc";
+import { uploadBlob } from "@/lib/uploads";
+
+import { getDocumentEditor } from "./editor";
+import { authoredTime } from "./timing";
+
+import type { Asset, AudioAsset, VideoAsset } from "@diffusionstudio/assets";
+import type { Entity, World } from "koota";
+
+export { autocutWouldChange, planAutocutTimeline };
+
+const TIMING_PROPS = new Set(["start", "end", "sourceIn", "sourceOut"]);
+const transcriptCache = new Map<string, Transcript["segments"]>();
+
+function isAutocutAssetType(type: string | undefined): boolean {
+  return type === "VIDEO" || type === "SEQUENCE" || type === "AUDIO";
+}
+
+function mediaSrcFromAuthored(tag: string | undefined, src: unknown): string | null {
+  if (tag !== "video" && tag !== "audio") return null;
+  return typeof src === "string" && src.length > 0 ? src : null;
+}
+
+function trimmedClipTiming(spec: AutocutClipSpec) {
+  return {
+    start: spec.timelineStart,
+    end: spec.timelineEnd,
+    sourceIn: spec.sourceIn,
+    sourceOut: spec.sourceOut,
+  };
+}
+
+function mergeAuthoredTiming(props: Record<string, unknown>, spec: AutocutClipSpec): Record<string, unknown> {
+  return { ...props, ...trimmedClipTiming(spec) };
+}
+
+async function transcribeForAutocut(asset: Asset): Promise<Transcript> {
+  let segments = transcriptCache.get(asset.id);
+  if (segments) return { segments };
+
+  try {
+    const audioFile = await transcodeForTranscription(asset);
+    const fileRef = await uploadBlob(audioFile, crypto.randomUUID());
+    if (!fileRef) throw new Error("Failed to upload asset for transcription.");
+
+    ({ results: segments } = await trpc.transcribe.mutate({ audio: fileRef }));
+  } catch {
+    return { segments: [] };
+  }
+
+  if (!segments.length || segments.every((s) => s.words.length === 0)) {
+    return { segments: [] };
+  }
+
+  transcriptCache.set(asset.id, segments);
+  return { segments };
+}
+
+/** Whether a selected timeline node is a single Autocut target (library or path-based). */
+export function isAutocutClip(world: World, entity: Entity): boolean {
+  const asset = findGeometryAsset(world, entity);
+  if (asset && isAutocutAssetType(asset.type)) return true;
+
+  const authored = authoredElement(entity);
+  if (!authored) return false;
+  if (authored.tag === "video" || authored.tag === "audio") {
+    return mediaSrcFromAuthored(authored.tag, authored.props.src) !== null;
+  }
+  return false;
+}
+
+function clipSourcePath(world: World, entity: Entity): string | null {
+  const authored = authoredElement(entity);
+  if (!authored) return null;
+
+  const direct = mediaSrcFromAuthored(authored.tag, authored.props.src);
+  if (direct) return direct;
+
+  const tree = authoredTree(world, entity);
+  if (!tree) return null;
+  for (const child of tree.children) {
+    if (child.tag !== "videoPaint") continue;
+    const src = child.props.src;
+    if (typeof src === "string" && src.length > 0) return src;
+  }
+  return null;
+}
+
+async function resolveTimelineMediaAsset(
+  world: World,
+  entity: Entity,
+): Promise<VideoAsset | AudioAsset | null> {
+  const bound = findGeometryAsset(world, entity);
+  if (bound && isAutocutAssetType(bound.type)) {
+    return bound as VideoAsset | AudioAsset;
+  }
+
+  const path = clipSourcePath(world, entity);
+  if (!path) return null;
+
+  const asset = await getLibrary(world).resolve(path);
+  if (asset.type !== "VIDEO" && asset.type !== "AUDIO") return null;
+  return asset;
+}
+
+export async function analyzeClipForAutocut(world: World, entity: Entity): Promise<AutocutResult> {
+  const asset = await resolveTimelineMediaAsset(world, entity);
+  if (!asset) throw new Error("Could not resolve the clip's media source.");
+
+  const fps = world.get(FrameRate)?.value ?? 30;
+  const source = getSourceWindow(entity);
+  const sourceIn = framesToSeconds(source.in, fps);
+  const sourceOut = framesToSeconds(source.out, fps);
+
+  const { silences } = await waveformAsset(asset, { scale: 0.25 });
+  const transcript = await transcribeForAutocut(asset);
+
+  return computeAutocut(
+    {
+      duration: asset.duration,
+      silences,
+      transcript,
+      window: { start: sourceIn, end: sourceOut },
+    },
+    { silenceMin: 0.4, pad: 0.05, lang: "all" },
+  );
+}
+
+function staticProps(props: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (!TIMING_PROPS.has(key) && key !== "src") out[key] = value;
+  }
+  return out;
+}
+
+function spellClip(world: World, entity: Entity): AuthoredTree | undefined {
+  const tree = authoredTree(world, entity);
+  if (!tree) return undefined;
+  const props = { ...tree.props };
+  delete props.selected;
+  delete props.active;
+  return { ...tree, props };
+}
+
+function renderAuthoredCopy(tree: AuthoredTree, spec: AutocutClipSpec) {
+  return renderAuthored({
+    ...tree,
+    props: mergeAuthoredTiming(tree.props as Record<string, unknown>, spec),
+  });
+}
+
+function renderDirectClip(tag: string, src: unknown, spec: AutocutClipSpec, props: Record<string, unknown>) {
+  const timing = trimmedClipTiming(spec);
+  if (tag === "audio") {
+    return <Audio src={src as string} {...props} {...timing} />;
+  }
+  return <Video src={src as string} {...props} {...timing} />;
+}
+
+/** Replace one clip with trimmed copies on one timeline row. Returns the new entities. */
+export function applyAutocutToClip(world: World, entity: Entity, specs: AutocutClipSpec[]): Entity[] {
+  const editor = getDocumentEditor(world);
+  const authored = authoredElement(entity);
+  if (!authored) return [];
+
+  const parent = getParentEntity(entity);
+  if (!parent) return [];
+
+  const tag = authored.tag;
+  const isDirect = tag === "video" || tag === "audio";
+  const geometryTree = isDirect ? undefined : spellClip(world, entity);
+  if (!isDirect && !geometryTree) return [];
+
+  const src = isDirect ? authored.props.src : undefined;
+  const props = isDirect ? staticProps(authored.props as Record<string, unknown>) : undefined;
+
+  const siblings = getEntityChildren(world, parent);
+  const anchor = siblings[siblings.indexOf(entity) + 1];
+
+  editor.remove(entity);
+
+  const insertCopy = (spec: AutocutClipSpec) =>
+    isDirect
+      ? () => renderDirectClip(tag, src, spec, props!)
+      : () => renderAuthoredCopy(geometryTree!, spec);
+
+  const rowParent = isGroup(parent) || isSequence(parent) ? parent : null;
+  if (rowParent) {
+    const created: Entity[] = [];
+    for (const spec of specs) {
+      created.push(...editor.insertElement(rowParent, insertCopy(spec), anchor));
+    }
+    if (created.length) editor.select(created);
+    return created;
+  }
+
+  const [sequence] = editor.insertElement(
+    parent,
+    () => <Sequence name={getNextName(world, "Sequence")} />,
+    anchor,
+  );
+  if (!sequence) return [];
+
+  const created: Entity[] = [];
+  for (const spec of specs) {
+    created.push(...editor.insertElement(sequence, insertCopy(spec)));
+  }
+  if (created.length) editor.select(created);
+  return created;
+}
+
+export function timelineStartSeconds(world: World, entity: Entity): number {
+  const fps = world.get(FrameRate)?.value ?? 30;
+  return framesToSeconds(authoredTime(world, entity, "start") ?? 0, fps);
+}
diff --git a/packages/runtime/src/media/autocut.test.ts b/packages/runtime/src/media/autocut.test.ts
new file mode 100644
index 00000000..64746521
--- /dev/null
+++ b/packages/runtime/src/media/autocut.test.ts
@@ -0,0 +1,113 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  autocutWouldChange,
+  computeAutocut,
+  formatAutocutJsx,
+  planAutocutTimeline,
+} from "./autocut.ts";
+
+const emptyTranscript = { segments: [] as Array<{ text: string; words: Array<{ text: string; start: number; end: number }> }> };
+
+test("drops silences at or above silenceMin", () => {
+  const result = computeAutocut(
+    {
+      duration: 10,
+      silences: [
+        { start: 2, end: 3.5 },
+        { start: 4, end: 4.2 },
+      ],
+      transcript: emptyTranscript,
+    },
+    { silenceMin: 0.4, pad: 0 },
+  );
+  assert.deepEqual(result.removed.silences, [{ start: 2, end: 3.5 }]);
+  assert.deepEqual(result.keep, [
+    { start: 0, end: 2 },
+    { start: 3.5, end: 10 },
+  ]);
+});
+
+test("stutter drops only the repeated word", () => {
+  const result = computeAutocut(
+    {
+      duration: 5,
+      silences: [],
+      transcript: {
+        segments: [
+          {
+            text: "I I think",
+            words: [
+              { text: "I", start: 0.2, end: 0.35 },
+              { text: "I", start: 0.36, end: 0.48 },
+              { text: "think", start: 0.5, end: 0.9 },
+            ],
+          },
+        ],
+      },
+    },
+    { pad: 0 },
+  );
+  assert.deepEqual(result.removed.stutters, [{ start: 0.36, end: 0.48 }]);
+  assert.ok(result.keep.some((r) => r.start <= 0.2 && r.end >= 0.35));
+  assert.ok(result.keep.some((r) => r.start <= 0.5 && r.end >= 0.9));
+});
+
+test("conservative fillers drop vocal pauses and safe phrases only", () => {
+  const result = computeAutocut(
+    {
+      duration: 8,
+      silences: [],
+      transcript: {
+        segments: [
+          {
+            text: "so like um you know well",
+            words: [
+              { text: "so", start: 0.2, end: 0.4 },
+              { text: "like", start: 0.5, end: 0.7 },
+              { text: "um", start: 0.8, end: 1.0 },
+              { text: "you", start: 1.1, end: 1.25 },
+              { text: "know", start: 1.26, end: 1.45 },
+              { text: "well", start: 1.5, end: 1.7 },
+            ],
+          },
+        ],
+      },
+    },
+    { pad: 0, lang: "en" },
+  );
+  assert.equal(result.removed.fillers.length, 2);
+  assert.ok(result.removed.fillers.some((r) => r.start === 0.8 && r.end === 1));
+  assert.ok(result.removed.fillers.some((r) => r.start === 1.1 && r.end === 1.45));
+});
+
+test("planAutocutTimeline chains clips on the timeline", () => {
+  const specs = planAutocutTimeline(
+    [
+      { start: 1, end: 3 },
+      { start: 5, end: 6 },
+    ],
+    2,
+  );
+  assert.deepEqual(specs, [
+    { timelineStart: 2, timelineEnd: 4, sourceIn: 1, sourceOut: 3 },
+    { timelineStart: 4, timelineEnd: 5, sourceIn: 5, sourceOut: 6 },
+  ]);
+});
+
+test("autocutWouldChange is false when nothing was removed", () => {
+  assert.equal(
+    autocutWouldChange({ silences: [], fillers: [], stutters: [] }),
+    false,
+  );
+  assert.equal(
+    autocutWouldChange({ silences: [{ start: 1, end: 2 }], fillers: [], stutters: [] }),
+    true,
+  );
+});
+
+test("formatAutocutJsx uses probe dimensions when provided", () => {
+  const jsx = formatAutocutJsx("clip.mp4", [{ start: 0, end: 2 }], { width: 1280, height: 720 });
+  assert.match(jsx, /width=\{1280\}/);
+  assert.match(jsx, /height=\{720\}/);
+});
diff --git a/packages/runtime/src/media/autocut.ts b/packages/runtime/src/media/autocut.ts
new file mode 100644
index 00000000..f220ebe9
--- /dev/null
+++ b/packages/runtime/src/media/autocut.ts
@@ -0,0 +1,245 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+export type TimeRange = { start: number; end: number };
+
+export type TranscriptWord = { text: string; start: number; end: number };
+export type TranscriptSegment = { text: string; words: TranscriptWord[] };
+export type Transcript = { segments: TranscriptSegment[] };
+
+export type AutocutOptions = {
+  silenceMin?: number;
+  pad?: number;
+  lang?: "en" | "es" | "all";
+};
+
+export type AutocutInput = {
+  duration: number;
+  silences: TimeRange[];
+  transcript: Transcript;
+  window?: { start: number; end: number };
+};
+
+export type AutocutRemoved = {
+  silences: TimeRange[];
+  fillers: TimeRange[];
+  stutters: TimeRange[];
+};
+
+export type AutocutResult = {
+  duration: number;
+  keep: TimeRange[];
+  removed: AutocutRemoved;
+};
+
+export type AutocutClipSpec = {
+  timelineStart: number;
+  timelineEnd: number;
+  sourceIn: number;
+  sourceOut: number;
+};
+
+const STUTTER_MAX_GAP = 0.35;
+
+const FILLERS_EN = new Set(["eh", "um", "uh", "er", "ah", "hmm", "hm", "uhm", "erm"]);
+const FILLERS_ES = new Set(["eh", "em", "um", "uh", "er", "ah", "hmm", "hm"]);
+
+const FILLER_PHRASES_EN: string[][] = [["you", "know"], ["i", "mean"]];
+const FILLER_PHRASES_ES: string[][] = [["o", "sea"], ["es", "decir"]];
+
+function normalizeToken(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}']/gu, "")
+    .trim();
+}
+
+function mergeRanges(ranges: TimeRange[]): TimeRange[] {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a.start - b.start);
+  const merged: TimeRange[] = [{ ...sorted[0] }];
+  for (let i = 1; i < sorted.length; i++) {
+    const cur = sorted[i];
+    const last = merged[merged.length - 1];
+    if (cur.start <= last.end) last.end = Math.max(last.end, cur.end);
+    else merged.push({ ...cur });
+  }
+  return merged;
+}
+
+function flattenWords(transcript: Transcript): TranscriptWord[] {
+  return transcript.segments.flatMap((s) => s.words);
+}
+
+function findStutters(words: TranscriptWord[]): TimeRange[] {
+  const drops: TimeRange[] = [];
+  for (let i = 1; i < words.length; i++) {
+    const prev = words[i - 1];
+    const cur = words[i];
+    const prevNorm = normalizeToken(prev.text);
+    const curNorm = normalizeToken(cur.text);
+    if (!prevNorm || prevNorm !== curNorm) continue;
+    const gap = cur.start - prev.end;
+    if (gap <= STUTTER_MAX_GAP) drops.push({ start: cur.start, end: cur.end });
+  }
+  return drops;
+}
+
+function fillerSets(lang: AutocutOptions["lang"]): { singles: Set<string>; phrases: string[][] } {
+  if (lang === "en") return { singles: FILLERS_EN, phrases: FILLER_PHRASES_EN };
+  if (lang === "es") return { singles: FILLERS_ES, phrases: FILLER_PHRASES_ES };
+  const singles = new Set([...FILLERS_EN, ...FILLERS_ES]);
+  return { singles, phrases: [...FILLER_PHRASES_EN, ...FILLER_PHRASES_ES] };
+}
+
+function findFillers(words: TranscriptWord[], lang: AutocutOptions["lang"]): TimeRange[] {
+  const { singles, phrases } = fillerSets(lang ?? "all");
+  const tokens = words.map((w) => ({ ...w, norm: normalizeToken(w.text) }));
+  const drops: TimeRange[] = [];
+  const used = new Set<number>();
+
+  for (const phrase of phrases) {
+    for (let i = 0; i <= tokens.length - phrase.length; i++) {
+      if (phrase.every((part, j) => tokens[i + j]?.norm === part)) {
+        for (let j = 0; j < phrase.length; j++) used.add(i + j);
+        drops.push({ start: tokens[i].start, end: tokens[i + phrase.length - 1].end });
+      }
+    }
+  }
+
+  for (let i = 0; i < tokens.length; i++) {
+    if (used.has(i)) continue;
+    if (singles.has(tokens[i].norm)) drops.push({ start: tokens[i].start, end: tokens[i].end });
+  }
+
+  return drops;
+}
+
+function filterSilences(silences: TimeRange[], silenceMin: number): TimeRange[] {
+  return silences.filter((s) => s.end - s.start >= silenceMin);
+}
+
+export function computeAutocut(input: AutocutInput, opts: AutocutOptions = {}): AutocutResult {
+  const silenceMin = opts.silenceMin ?? 0.4;
+  const pad = opts.pad ?? 0.05;
+  const duration = input.duration;
+  const window = input.window;
+
+  const words = flattenWords(input.transcript).filter((w) => {
+    if (!window) return true;
+    return w.end > window.start && w.start < window.end;
+  });
+
+  const silenceDrops = filterSilences(input.silences, silenceMin);
+  const fillerDrops = findFillers(words, opts.lang);
+  const stutterDrops = findStutters(words);
+
+  const windowDrops: TimeRange[] = [];
+  if (window) {
+    if (window.start > 0) windowDrops.push({ start: 0, end: window.start });
+    if (window.end < duration) windowDrops.push({ start: window.end, end: duration });
+  }
+
+  const removed: AutocutRemoved = {
+    silences: silenceDrops,
+    fillers: fillerDrops,
+    stutters: stutterDrops,
+  };
+
+  const drop = mergeRanges([...silenceDrops, ...fillerDrops, ...stutterDrops, ...windowDrops]);
+  const keep = invertRangesWithPad(drop, duration, pad);
+
+  return { duration, keep, removed };
+}
+
+export function autocutWouldChange(removed: AutocutRemoved): boolean {
+  return removed.silences.length + removed.fillers.length + removed.stutters.length > 0;
+}
+
+export function planAutocutTimeline(keep: TimeRange[], timelineStartSec: number): AutocutClipSpec[] {
+  let cursor = timelineStartSec;
+  return keep.map((range) => {
+    const dur = range.end - range.start;
+    const spec = {
+      timelineStart: cursor,
+      timelineEnd: cursor + dur,
+      sourceIn: range.start,
+      sourceOut: range.end,
+    };
+    cursor += dur;
+    return spec;
+  });
+}
+
+function invertRangesWithPad(drop: TimeRange[], duration: number, pad: number): TimeRange[] {
+  const merged = mergeRanges(drop);
+  if (merged.length === 0) return duration > 0 ? [{ start: 0, end: duration }] : [];
+
+  const keep: TimeRange[] = [];
+  let cursor = 0;
+  for (const span of merged) {
+    const cutStart = Math.max(0, span.start);
+    const cutEnd = Math.min(duration, span.end);
+    if (cutStart > cursor) {
+      keep.push({
+        start: cursor,
+        end: Math.min(duration, cutStart + pad),
+      });
+    }
+    cursor = Math.max(cursor, cutEnd);
+  }
+  if (cursor < duration) {
+    const start = Math.max(0, cursor - pad);
+    const last = keep[keep.length - 1];
+    if (last && start <= last.end) last.end = duration;
+    else keep.push({ start, end: duration });
+  }
+
+  return mergeRanges(
+    keep
+      .map((r) => ({
+        start: Math.max(0, r.start),
+        end: Math.min(duration, r.end),
+      }))
+      .filter((r) => r.end - r.start > 0.01),
+  );
+}
+
+export type AutocutJsxOptions = {
+  width?: number;
+  height?: number;
+  kind?: "video" | "audio";
+};
+
+export function formatAutocutJsx(src: string, keep: TimeRange[], opts: AutocutJsxOptions = {}): string {
+  const tag = opts.kind === "audio" ? "audio" : "video";
+  const dims =
+    tag === "video" && typeof opts.width === "number" && typeof opts.height === "number"
+      ? ` width={${opts.width}} height={${opts.height}}`
+      : "";
+
+  const clips = keep
+    .map((range, i) => {
+      const timelineStart = keep.slice(0, i).reduce((acc, r) => acc + (r.end - r.start), 0);
+      const dur = range.end - range.start;
+      const timelineEnd = timelineStart + dur;
+      const srcIn = formatJsxTime(range.start);
+      const srcOut = formatJsxTime(range.end);
+      const start = formatJsxTime(timelineStart);
+      const end = formatJsxTime(timelineEnd);
+      return `  <${tag} src="${escapeJsxAttr(src)}"${dims} start={${start}} end={${end}} sourceIn={${srcIn}} sourceOut={${srcOut}} />`;
+    })
+    .join("\n");
+
+  return `<sequence>\n${clips}\n</sequence>`;
+}
+
+function formatJsxTime(seconds: number): string {
+  const rounded = Math.round(seconds * 1000) / 1000;
+  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(3).replace(/\.?0+$/, "");
+}
+
+function escapeJsxAttr(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
diff --git a/packages/runtime/src/media/index.ts b/packages/runtime/src/media/index.ts
index b30f5a43..92e05aad 100644
--- a/packages/runtime/src/media/index.ts
+++ b/packages/runtime/src/media/index.ts
@@ -17,4 +17,5 @@ export * from './sequence';
 export * from './shader';
 export * from './time-stretcher';
 export * from './transcode';
+export * from './autocut';
 export * from './video';
diff --git a/packages/runtime/tsconfig.json b/packages/runtime/tsconfig.json
index 516eda7b..8091cf6e 100644
--- a/packages/runtime/tsconfig.json
+++ b/packages/runtime/tsconfig.json
@@ -6,5 +6,6 @@
     "lib": ["es2024", "DOM", "DOM.Iterable"],
     "types": ["@webgpu/types"]
   },
-  "include": ["src"]
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"]
 }
diff --git a/reference/README.md b/reference/README.md
index 71fd8f9e..42e460d3 100644
--- a/reference/README.md
+++ b/reference/README.md
@@ -17,7 +17,7 @@ A project is a folder of that JSX, and **the source is the document**: the app c
 How the surface is divided:
 
 - AI asset generation (image / video / speech / audio) is declared in the project module (`generate.*`, see [jsx/generate.md](./jsx/generate.md)). `models` and `voices` list what those declarations can reference.
-- Inspecting an existing asset (probe / transcribe / listen / filmstrip / waveform / grab) lives under `media`.
+- Inspecting an existing asset (probe / transcribe / listen / filmstrip / waveform / grab / autocut) lives under `media`.
 
 ## Commands
 
@@ -42,6 +42,7 @@ How the surface is divided:
 - [`dapi media grab`](./media/grab.md): decode video frames to a labelled contact sheet, or one PNG per frame
 - [`dapi media filmstrip`](./media/filmstrip.md): grid of video frames as a PNG
 - [`dapi media waveform`](./media/waveform.md): audio waveform PNG with silence highlighting
+- [`dapi media autocut`](./media/autocut.md): propose keep-ranges by dropping silences, stutters, and fillers
 - [`dapi media listen`](./media/listen.md): AI description of an audio track
 
 ### Generation reference
diff --git a/reference/media/autocut.md b/reference/media/autocut.md
new file mode 100644
index 00000000..0c3d5a58
--- /dev/null
+++ b/reference/media/autocut.md
@@ -0,0 +1,54 @@
+# `dapi media autocut <path>`
+
+Proposes **keep-ranges** for a CapCut-style jump cut by composing [`dapi media waveform`](./waveform.md) silence detection with [`dapi media transcribe`](./transcribe.md) word timings. Does not re-encode or write media — it returns second ranges (and optionally a JSX `<sequence>`) for trimming with `sourceIn` / `sourceOut`.
+
+Dropped spans:
+
+- **Silences** — from the waveform analyzer (same amplitude threshold as `media waveform`), kept only when at least `--silence-min` long.
+- **Stutters** — immediate repeated words (`"I I think"`).
+- **Fillers** — vocal pauses (`um`, `uh`, `eh`, `em`, …) and a few safe phrases (`you know`, `i mean`, `o sea`, `es decir`). Real conjunctions and adverbs (`so`, `like`, `well`, `vale`, …) are not dropped.
+
+All times are **source/content seconds**, the same clock as [`media transcribe`](./transcribe.md) and [`media waveform`](./waveform.md). Waveform `silences[]` are absolute source seconds (when `--start`/`--end` narrow the window, silence timestamps are still offset into source time, not relative to the window).
+
+## Input
+
+- `<path>`: a local video or audio file, or a project library path (library paths need an open project).
+- `-s, --start <time>`: start of the window to analyze, a `Time` value (optional; default `0`). Passed through to waveform silence detection; transcript words outside the window are ignored.
+- `-e, --end <time>`: end of the window (optional; default the asset's duration).
+- `--silence-min <seconds>`: drop silences at least this long (optional; default `0.4`). The waveform's amplitude threshold is fixed in the app.
+- `--pad <seconds>`: keep this much audio on each side of a cut (optional; default `0.05`).
+- `--lang <code>`: filler vocabulary — `en`, `es`, or `all` (optional; default `all`).
+- `--jsx`: include a JSX `<sequence>` of `<video>` or `<audio>` clips with `sourceIn` / `sourceOut` for each kept span (optional).
+
+Transcription uses cloud STT when signed in (cached like `media transcribe`). When transcription fails or no speech is detected, the command continues with **silence-only** cuts.
+
+## Output
+
+One JSON object:
+
+```ts
+{
+  duration: number,
+  keep: Array<{ start: number, end: number }>,  // source seconds to keep
+  removed: {
+    silences: Array<{ start: number, end: number }>,
+    fillers: Array<{ start: number, end: number }>,
+    stutters: Array<{ start: number, end: number }>,
+  },
+  jsx?: string,  // when --jsx; video uses probe width/height when present, audio uses <audio>
+}
+```
+
+Times are in **source/content seconds**, the same clock as `transcribe` and `waveform`.
+
+## Errors
+
+Exits non-zero if the path can't be resolved, probe can't read a duration, the asset has no decodable audio, or flags are invalid.
+
+When the audio has no recognizable speech or cloud STT is unavailable, the command continues with silence-only cuts and prints a note to stderr.
+
+## Example
+
+```sh
+dapi media autocut interview.mp4 --jsx
+```