diff --git a/README.md b/README.md
index 06d5e33..b52ea62 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,7 @@ Most editors keep a project in a format built for their own app, not for you or
 - **Formats**: 16:9, 9:16 for Reels, TikTok and Shorts, 1:1, 4:5 and 4:3, or the shape of your own footage. Titles and logos keep their size and place when the shape changes, and clips either fit with bars or fill the frame.
 - **Crop**: keep part of any clip, logo or picture-in-picture, free or held to 16:9, 9:16, 1:1, 4:5 or the video's own shape, with a scrubber to check the subject stays inside. The preview places a cropped clip exactly as the export does.
 - **Fades**: fade a clip up from black and down to black, its sound with it, or make a fade through black between two clips. Titles, logos and music fade in and out the same way, and the preview plays each fade as it will export.
+- **Colour**: brightness, contrast, saturation and temperature on any clip, logo or picture-in-picture, and one click to give every clip the same look, for flat log footage or two cameras that do not match. The preview draws it with the same maths the export renders.
 - **Transitions**: put a dissolve, a fade through black or white, a wipe, a slide, a blur or a pixelate on any cut, from the mark between two clips on the timeline, or on every cut at once. A transition is centred on its cut and moves no clip, so titles and music stay where you put them, and the preview draws each one frame for frame as it exports.
 - **Captions**: switch them on for the whole video, pick one of twelve languages and one style. The words come from each clip's transcript, so captions follow every trim, split and reorder.
 - **Ask for a change**: describe an edit in your own words and it is applied to the cut you have. The model calls a fixed set of checked operations, so the edit is always a valid document. One instruction, one undo.
diff --git a/agent.md b/agent.md
index 3d07253..2a12b4f 100644
--- a/agent.md
+++ b/agent.md
@@ -309,7 +309,15 @@ its in-point, into the footage beyond their trims (a clip that starts at 0:00
 holds its first frame for that part). So overlay and audio times stay where
 they are and the video keeps its length. One longer than the clips on either
 side allow is shortened to fit, and one on the first clip is left out of the
-export. Text overlays: `fontFamily`
+export. Every main-track clip and media overlay takes `adjust: { "brightness",
+"contrast", "saturation", "temperature" }`, each -1..1 with 0 leaving the
+picture alone (the editor shows -100..100): brightness is a gain (1 doubles,
+-1 halves), contrast pivots on mid grey, saturation -1 is black and white, and
+temperature above 0 is warmer. Leave out what you do not change. Flat log
+footage usually wants contrast and saturation up (0.2 to 0.4 each); footage
+from one camera usually wants the same values on every clip of it. You cannot
+see the picture: change colour when asked, or when a clip's log says it is
+flat, dark or off-colour, and say what you set. Text overlays: `fontFamily`
 (`sans`/`serif`/`mono`), `fontSize` in px at output resolution, optional boxed
 `background` (`#RRGGBBAA` works), optional `stroke: { "color": "#000000",
 "width": 4 }` for an outline around the letters (opaque colour; `width` in px
diff --git a/src/client/edit.tsx b/src/client/edit.tsx
index 5aa1c3b..ad616d9 100644
--- a/src/client/edit.tsx
+++ b/src/client/edit.tsx
@@ -35,6 +35,7 @@ import {
   type Transition,
   type TransitionType,
 } from "../shared/transition";
+import { ADJUST_KEYS, adjustSteps, cleanAdjust, type Adjust, type AdjustKey } from "../shared/adjust";
 import {
   FULL,
   cropToRatio,
@@ -191,6 +192,8 @@ interface MainVideo {
   anchor?: Anchor;
   /** The part of the source kept, cut out before fitting (shared/crop.ts). */
   crop?: Crop;
+  /** Colour adjustment, the export's own maths (shared/adjust.ts). */
+  adjust?: Adjust;
   /** Seconds to fade from and to black (shared/fade.ts). */
   fadeIn?: number;
   fadeOut?: number;
@@ -205,6 +208,7 @@ interface MainImage {
   fit?: "contain" | "cover";
   anchor?: Anchor;
   crop?: Crop;
+  adjust?: Adjust;
   /** Seconds to fade from and to black (shared/fade.ts). */
   fadeIn?: number;
   fadeOut?: number;
@@ -225,6 +229,7 @@ interface OverlayMedia {
   trimStart?: number;
   trimEnd?: number;
   crop?: Crop;
+  adjust?: Adjust;
   /** Seconds to fade from and to transparent, the out ending where it is last seen. */
   fadeIn?: number;
   fadeOut?: number;
@@ -3149,6 +3154,8 @@ function Player({
   /** A clip's sound in a transition, on acrossfade's curve; 1 otherwise. */
   const crossGain = (seg: Seg) => (blend && seg === blend.from ? blend.look.gains[0] : blend && seg === blend.to ? blend.look.gains[1] : 1);
   const filterId = useId().replace(/:/g, "");
+  // An element id can be any string; a url(#…) reference cannot.
+  const adjustId = (elementId: string) => `${filterId}-adj-${elementId.replace(/[^\w-]/g, "_")}`;
   /** An overlay's opacity right now: its own times its fades. */
   const overlayOpacity = (el: { startTime: number; duration: number; opacity?: number; fadeIn?: number; fadeOut?: number }) =>
     (el.opacity ?? 1) * fadeGain(el, heardFor(el.startTime, el.duration, cutLength), playhead - el.startTime);
@@ -3459,8 +3466,13 @@ function Player({
                   filter: effect,
                 }}
               >
-              {/* The same wrapper either way, so cropping never reloads the video. */}
-              <div className={`absolute ${place ? "overflow-hidden" : "inset-0"}`} style={place ? pct(place.box) : undefined}>
+              {seg.el.adjust && <AdjustFilter id={adjustId(seg.el.id)} adjust={seg.el.adjust} />}
+              {/* The same wrapper either way, so cropping never reloads the
+                  video. Its colour is adjusted, never the bars around it. */}
+              <div
+                className={`absolute ${place ? "overflow-hidden" : "inset-0"}`}
+                style={{ ...(place ? pct(place.box) : {}), filter: adjustUrl(adjustId(seg.el.id), seg.el.adjust) }}
+              >
                 {seg.el.type === "video" ? (
                   a.media_uid ? (
                     <MediaVideo
@@ -3542,6 +3554,8 @@ function Player({
                     ) : (
                       <video ref={keep(overlayRefs.current, m.id)} src={assetUrl(a)} preload="auto" playsInline muted {...props} />
                     );
+                  const colour = adjustUrl(adjustId(m.id), m.adjust);
+                  const adjustDefs = m.adjust && <AdjustFilter id={adjustId(m.id)} adjust={m.adjust} />;
                   const shape = m.crop ? shapeFor(a) : undefined;
                   if (shape && m.crop) {
                     const kept = croppedShape(shape, m.crop);
@@ -3560,10 +3574,11 @@ function Player({
                           display: show ? undefined : "none",
                         }}
                       >
+                        {adjustDefs}
                         {m.type === "image" ? (
-                          <img src={assetUrl(a)} className="absolute max-w-none pointer-events-none" style={pct(source)} />
+                          <img src={assetUrl(a)} className="absolute max-w-none pointer-events-none" style={{ ...pct(source), filter: colour }} />
                         ) : (
-                          overlayVideo({ className: "absolute max-w-none pointer-events-none", style: { ...pct(source), objectFit: "fill" } })
+                          overlayVideo({ className: "absolute max-w-none pointer-events-none", style: { ...pct(source), objectFit: "fill", filter: colour } })
                         )}
                       </div>
                     );
@@ -3575,10 +3590,11 @@ function Player({
                       className={`absolute cursor-move ${selected ? "outline outline-2 outline-ring" : ""}`}
                       style={{ left: `${m.x * 100}%`, top: `${m.y * 100}%`, width: `${m.width * 100}%`, opacity: overlayOpacity(m), display: show ? undefined : "none" }}
                     >
+                      {adjustDefs}
                       {m.type === "image" ? (
-                        <img src={assetUrl(a)} onLoad={noteSize(a.id)} className="w-full h-auto pointer-events-none" />
+                        <img src={assetUrl(a)} onLoad={noteSize(a.id)} className="w-full h-auto pointer-events-none" style={{ filter: colour }} />
                       ) : (
-                        overlayVideo({ onLoadedMetadata: noteSize(a.id), className: "w-full h-auto pointer-events-none" })
+                        overlayVideo({ onLoadedMetadata: noteSize(a.id), className: "w-full h-auto pointer-events-none", style: { filter: colour } })
                       )}
                     </div>
                   );
@@ -3650,6 +3666,33 @@ function TransitionFilter({ id, blurBox, block, scale }: { id: string; blurBox?:
   );
 }
 
+/**
+ * A clip's colour adjustment as an SVG filter: step 1 one colour matrix,
+ * step 2 the red and blue gains, each clamped, in the encoded RGB the export
+ * works in (sRGB interpolation, not SVG's default linear light).
+ */
+function AdjustFilter({ id, adjust }: { id: string; adjust: Adjust }) {
+  const { matrix, offset, warmth } = adjustSteps(adjust);
+  return (
+    <svg className="absolute w-0 h-0" aria-hidden>
+      <filter id={id} x="0" y="0" width="100%" height="100%" colorInterpolationFilters="sRGB">
+        {matrix && (
+          <feColorMatrix type="matrix" values={matrix.map((row) => `${row.join(" ")} 0 ${offset}`).join(" ") + " 0 0 0 1 0"} />
+        )}
+        {warmth && (
+          <feComponentTransfer>
+            <feFuncR type="linear" slope={warmth[0]} />
+            <feFuncB type="linear" slope={warmth[1]} />
+          </feComponentTransfer>
+        )}
+      </filter>
+    </svg>
+  );
+}
+
+/** The CSS `filter` that draws an element's adjustment, if it has one. */
+const adjustUrl = (id: string, adjust: Adjust | undefined) => (cleanAdjust(adjust) ? `url(#${id})` : undefined);
+
 /** A rectangle in shares of its container, as CSS. */
 const pct = (r: { left: number; top: number; width: number; height: number }): React.CSSProperties => ({
   left: `${r.left * 100}%`,
@@ -4374,6 +4417,71 @@ function Fades({
   );
 }
 
+const ADJUST_LABELS: Record<AdjustKey, string> = {
+  brightness: "Brightness",
+  contrast: "Contrast",
+  saturation: "Saturation",
+  temperature: "Temperature",
+};
+
+/**
+ * A clip's colour: -100..100 here, -1..1 in the EDL, drawn in the preview as
+ * the export renders it (shared/adjust.ts). Double-click a slider to zero it.
+ * `onApplyAll` gives every clip on the main track the same look: footage from
+ * one camera usually needs one fix throughout.
+ */
+function ColourAdjust({
+  adjust,
+  onChange,
+  onApplyAll,
+}: {
+  adjust?: Adjust;
+  onChange: (a: Adjust | undefined) => void;
+  onApplyAll?: () => void;
+}) {
+  const a = cleanAdjust(adjust);
+  const set = (k: AdjustKey, v: number) => onChange(cleanAdjust({ ...a, [k]: v / 100 }));
+  return (
+    <Field label="Colour">
+      {ADJUST_KEYS.map((k) => {
+        const v = Math.round((a?.[k] ?? 0) * 100);
+        return (
+          <label key={k} className="block mb-1.5">
+            <span className="flex justify-between text-fine text-muted">
+              <span>{ADJUST_LABELS[k]}</span>
+              <span className="tabular-nums">{v > 0 ? `+${v}` : v}</span>
+            </span>
+            <input
+              type="range"
+              className="w-full"
+              min={-100}
+              max={100}
+              step={1}
+              value={v}
+              onChange={(e) => set(k, Number(e.target.value))}
+              onDoubleClick={() => set(k, 0)}
+            />
+          </label>
+        );
+      })}
+      {(a || onApplyAll) && (
+        <div className="flex gap-1 -ml-2">
+          {a && (
+            <button className={btnGhost} onClick={() => onChange(undefined)}>
+              Reset
+            </button>
+          )}
+          {onApplyAll && (
+            <button className={btnGhost} onClick={onApplyAll}>
+              Apply to all clips
+            </button>
+          )}
+        </div>
+      )}
+    </Field>
+  );
+}
+
 /**
  * A style's icon: how the picture changes, drawn small. Wipes and slides are
  * drawn moving left and turned for the other directions.
@@ -4659,6 +4767,18 @@ function Inspector({
           )}
         </>
       );
+      const mainColour = (
+        <ColourAdjust
+          adjust={el.adjust}
+          // One drag, one undo step.
+          onChange={(adj) => update((d) => void (d.main.elements[sel.i].adjust = adj), true)}
+          onApplyAll={
+            edl.main.elements.length > 1
+              ? () => update((d) => d.main.elements.forEach((e) => (e.adjust = cleanAdjust(el.adjust))))
+              : undefined
+          }
+        />
+      );
       return (
         <>
           <Zone>{el.type === "video" ? "Video clip" : "Image"}</Zone>
@@ -4680,6 +4800,7 @@ function Inspector({
                 />
               )}
               {mainCrop(el)}
+              {mainColour}
               <Row label="Clip audio">
                 <button
                   className={`${inputCls} text-left`}
@@ -4770,6 +4891,7 @@ function Inspector({
                 />
               )}
               {mainCrop(el)}
+              {mainColour}
               {mainFades}
             </>
           )}
@@ -4863,6 +4985,12 @@ function Inspector({
               }
             />
           )}
+          {el.type !== "text" && (
+            <ColourAdjust
+              adjust={el.adjust}
+              onChange={(adj) => update((d) => void ((d.overlays![sel.ti].elements[sel.i] as OverlayMedia).adjust = adj), true)}
+            />
+          )}
           <PositionRow
             el={el}
             frame={edl.output}
diff --git a/src/server/edl.ts b/src/server/edl.ts
index a1bd52f..6a82cd8 100644
--- a/src/server/edl.ts
+++ b/src/server/edl.ts
@@ -86,6 +86,17 @@ const transition = z
   })
   .strict();
 
+/** A colour adjustment, each field -1..1 (0 leaves the picture alone). The
+ *  maths is in shared/adjust.ts, the same as the edit service renders. */
+const adjust = z
+  .object({
+    brightness: z.number().finite().min(-1).max(1).optional(),
+    contrast: z.number().finite().min(-1).max(1).optional(),
+    saturation: z.number().finite().min(-1).max(1).optional(),
+    temperature: z.number().finite().min(-1).max(1).optional(),
+  })
+  .strict();
+
 const mainVideo = z
   .object({
     ...clipBase,
@@ -100,6 +111,7 @@ const mainVideo = z
     fit: fit.optional(),
     anchor: anchor.optional(),
     crop: crop.optional(),
+    adjust: adjust.optional(),
     /** Seconds to fade up from black, and down to black before the clip
      *  ends; a video clip's own sound fades with it. shared/fade.ts */
     fadeIn: seconds.max(MAX_FADE_SECONDS).optional(),
@@ -116,6 +128,7 @@ const mainImage = z
     fit: fit.optional(),
     anchor: anchor.optional(),
     crop: crop.optional(),
+    adjust: adjust.optional(),
     /** Seconds to fade up from black, and down to black before the clip
      *  ends; a video clip's own sound fades with it. shared/fade.ts */
     fadeIn: seconds.max(MAX_FADE_SECONDS).optional(),
@@ -147,6 +160,7 @@ const overlayMedia = z
     /** Fraction of canvas width; height keeps the (cropped) source aspect. */
     width: z.number().finite().min(0.01).max(1),
     crop: crop.optional(),
+    adjust: adjust.optional(),
   })
   .strict();
 
diff --git a/src/server/instruct.ts b/src/server/instruct.ts
index 4e98aed..a67091a 100644
--- a/src/server/instruct.ts
+++ b/src/server/instruct.ts
@@ -21,6 +21,7 @@ import {
   type TransitionType,
 } from "../shared/transition";
 import { FORMAT_PRESETS, reshape, sizeFor } from "../shared/format";
+import { ADJUST_KEYS, cleanAdjust, describeAdjust, type Adjust } from "../shared/adjust";
 
 const DEFAULT_SERVICES_URL = "https://services.clawnify.com";
 const MODEL = "google/gemini-3.7-flash";
@@ -63,6 +64,7 @@ export type AppliedOp = string;
 
 interface Clip {
   type: "video" | "image";
+  adjust?: Adjust;
   fadeIn?: number;
   fadeOut?: number;
   transition?: Transition;
@@ -128,6 +130,24 @@ const OPS = [
       required: ["clip"],
     },
   },
+  {
+    name: "adjust_color",
+    description:
+      "Change the colour of a main-track clip, of every main-track clip at once (`every`: footage from one camera usually needs one fix), or of a video or image overlay (`track` and `index`). Each value runs -100 to 100 and 0 is unchanged; temperature above 0 is warmer, below is cooler; saturation -100 is black and white. Values given replace the clip's own; values left out stay as they are. You cannot see the footage: change colour only when asked, and only as far as asked.",
+    parameters: {
+      type: "object",
+      properties: {
+        clip: { type: "integer", description: "0-based position on the main track" },
+        every: { type: "boolean", description: "every clip on the main track" },
+        track: { type: "integer", description: "overlay track of a video or image overlay" },
+        index: { type: "integer", description: "its position on that track" },
+        brightness: { type: "number" },
+        contrast: { type: "number" },
+        saturation: { type: "number" },
+        temperature: { type: "number" },
+      },
+    },
+  },
   {
     name: "fade",
     description:
@@ -290,6 +310,34 @@ export function apply(
       const what = args.clip !== undefined ? `clip ${args.clip}` : `${args.track}.${args.index}`;
       return { said: target.fadeIn || target.fadeOut ? `Set the fades on ${what}` : `Removed the fades on ${what}` };
     }
+    case "adjust_color": {
+      const given = ADJUST_KEYS.filter((k) => typeof args[k] === "number" && Number.isFinite(args[k]));
+      if (!given.length) return { error: `give at least one of ${ADJUST_KEYS.join(", ")}, from -100 to 100` };
+      let targets: { adjust?: Adjust }[];
+      let what: string;
+      if (args.every === true) {
+        targets = main;
+        what = "every clip";
+      } else if (args.clip !== undefined) {
+        const clip = clipAt(args.clip);
+        if (!clip) return { error: `there is no clip ${args.clip}` };
+        targets = [clip];
+        what = `clip ${args.clip}`;
+      } else {
+        const el = draft.overlays?.[Number(args.track)]?.elements[Number(args.index)];
+        if (!el || el.type === "text") return { error: "there is no video or image overlay there" };
+        targets = [el];
+        what = `overlay ${args.track}.${args.index}`;
+      }
+      for (const t of targets) {
+        const next: Adjust = { ...t.adjust };
+        for (const k of given) next[k] = (args[k] as number) / 100;
+        t.adjust = cleanAdjust(next);
+        if (!t.adjust) delete t.adjust;
+      }
+      const now = describeAdjust(targets[0].adjust);
+      return { said: now ? `Set the colour of ${what}: ${now}` : `Put the colour of ${what} back as shot` };
+    }
     case "transition": {
       const type = String(args.type ?? "");
       if (type !== "none" && !(TRANSITION_TYPES as readonly string[]).includes(type)) {
@@ -413,6 +461,12 @@ function fades(el: { fadeIn?: number; fadeOut?: number }): string {
   return parts.length ? `, ${parts.join(", ")}` : "";
 }
 
+/** A clip's colour, when it has been changed. */
+function colour(el: { adjust?: Adjust }): string {
+  const d = describeAdjust(el.adjust);
+  return d ? `, colour ${d}` : "";
+}
+
 /** How a clip comes in, when it does not simply cut in. */
 function joined(el: { transition?: Transition }, i: number): string {
   const t = i > 0 ? el.transition : undefined;
@@ -426,13 +480,13 @@ function describeEdl(edl: Edl, names: Map<string, string>): string {
     const from = el.trimStart ?? 0;
     const playing = "duration" in el && el.duration !== undefined ? `${el.duration.toFixed(1)}s` : "the rest";
     const audio = el.type === "video" && el.sourceAudio === false ? ", muted" : "";
-    return `  clip ${i}: "${name}" from ${from.toFixed(1)}s, plays ${playing}${audio}${fades(el)}${joined(el, i)}`;
+    return `  clip ${i}: "${name}" from ${from.toFixed(1)}s, plays ${playing}${audio}${colour(el)}${fades(el)}${joined(el, i)}`;
   });
   const texts = (edl.overlays ?? []).flatMap((track, ti) =>
     track.elements.map((el, i) =>
       el.type === "text"
         ? `  text ${ti}.${i}: "${el.text}" at ${el.startTime.toFixed(1)}s for ${el.duration.toFixed(1)}s${fades(el)}`
-        : `  overlay ${ti}.${i}: ${el.type}${fades(el)}`,
+        : `  overlay ${ti}.${i}: ${el.type}${colour(el)}${fades(el)}`,
     ),
   );
   return [
diff --git a/src/shared/adjust.ts b/src/shared/adjust.ts
new file mode 100644
index 0000000..a335722
--- /dev/null
+++ b/src/shared/adjust.ts
@@ -0,0 +1,79 @@
+// A clip's colour adjustment, in the edit service's own maths (its schema.ts
+// `adjust`), so the preview's SVG filter draws what the export renders.
+//
+// On gamma-encoded RGB in 0..1, two steps, each clamped to 0..1:
+//   1. y = k * g * S * x + (1 - k) / 2, where S is the saturation matrix with
+//      BT.709 weights (0.2126 / 0.7152 / 0.0722) and s = 1 + saturation (0 is
+//      greyscale), g = 2^brightness, k = 2^contrast (pivot: mid grey);
+//   2. temperature t scales red by 1 + 0.2 t and blue by 1 - 0.2 t (warm
+//      above 0).
+// The service renders step 1 in YUV, where it is a line per plane, and goes
+// to RGB only for step 2. Each field runs -1..1 and 0 leaves the picture
+// alone; people see -100..100.
+
+export interface Adjust {
+  brightness?: number;
+  contrast?: number;
+  saturation?: number;
+  temperature?: number;
+}
+
+export const ADJUST_KEYS = ["brightness", "contrast", "saturation", "temperature"] as const;
+export type AdjustKey = (typeof ADJUST_KEYS)[number];
+
+/**
+ * The adjustment as it should be stored: each field in -1..1 to two places,
+ * zeros dropped, and nothing at all when every field is 0.
+ */
+export function cleanAdjust(a: Adjust | undefined): Adjust | undefined {
+  if (!a) return undefined;
+  const out: Adjust = {};
+  for (const k of ADJUST_KEYS) {
+    const v = a[k];
+    if (typeof v !== "number" || !Number.isFinite(v)) continue;
+    const r = Math.round(Math.max(-1, Math.min(1, v)) * 100) / 100;
+    if (r !== 0) out[k] = r;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
+/** The two steps as filter values: step 1 as a 3x3 matrix and one offset
+ *  (null when it changes nothing), step 2 as red and blue gains (null
+ *  without temperature). */
+export function adjustSteps(a: Adjust): {
+  matrix: number[][] | null;
+  offset: number;
+  warmth: [number, number] | null;
+} {
+  const s = 1 + (a.saturation ?? 0);
+  const k = 2 ** (a.contrast ?? 0);
+  const g = 2 ** (a.brightness ?? 0);
+  const t = a.temperature ?? 0;
+  const w = [0.2126, 0.7152, 0.0722];
+  const matrix =
+    s === 1 && k === 1 && g === 1
+      ? null
+      : [0, 1, 2].map((c) => w.map((wi, j) => k * g * (j === c ? wi + (1 - wi) * s : wi - wi * s)));
+  return { matrix, offset: (1 - k) / 2, warmth: t === 0 ? null : [1 + 0.2 * t, 1 - 0.2 * t] };
+}
+
+/** One pixel (RGB 0..1) through the adjustment: the reference both the
+ *  preview and the export are held to. */
+export function adjustPixel(a: Adjust, rgb: [number, number, number]): [number, number, number] {
+  const { matrix, offset, warmth } = adjustSteps(a);
+  const c01 = (x: number) => Math.max(0, Math.min(1, x));
+  const one = matrix ? matrix.map((row) => c01(row[0] * rgb[0] + row[1] * rgb[1] + row[2] * rgb[2] + offset)) : rgb;
+  return warmth ? [c01(one[0] * warmth[0]), one[1], c01(one[2] * warmth[1])] : ([...one] as [number, number, number]);
+}
+
+/** "contrast +30, saturation -20", or "" when nothing is adjusted. */
+export function describeAdjust(a: Adjust | undefined): string {
+  const c = cleanAdjust(a);
+  if (!c) return "";
+  return ADJUST_KEYS.filter((k) => c[k] !== undefined)
+    .map((k) => {
+      const v = Math.round(c[k]! * 100);
+      return `${k} ${v > 0 ? "+" : ""}${v}`;
+    })
+    .join(", ");
+}
diff --git a/test/adjust.test.ts b/test/adjust.test.ts
new file mode 100644
index 0000000..c8c68e0
--- /dev/null
+++ b/test/adjust.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { adjustPixel, adjustSteps, cleanAdjust, describeAdjust } from "../src/shared/adjust";
+import { splitClip } from "../src/shared/split";
+
+describe("colour adjustment", () => {
+  it("leaves the picture alone at 0", () => {
+    expect(cleanAdjust({ brightness: 0, contrast: 0 })).toBeUndefined();
+    const steps = adjustSteps({});
+    expect(steps.matrix).toBeNull();
+    expect(steps.warmth).toBeNull();
+    expect(adjustPixel({}, [0.2, 0.5, 0.9])).toEqual([0.2, 0.5, 0.9]);
+  });
+
+  it("stores each field in -1..1 to two places", () => {
+    expect(cleanAdjust({ contrast: 1.7, saturation: -0.333, temperature: Number.NaN })).toEqual({ contrast: 1, saturation: -0.33 });
+    expect(describeAdjust({ contrast: 0.3, temperature: -0.25 })).toBe("contrast +30, temperature -25");
+  });
+
+  it("follows the edit service's maths", () => {
+    // Greyscale keeps luma (BT.709 weights 0.2126 / 0.7152 / 0.0722).
+    const [r, g, b] = adjustPixel({ saturation: -1 }, [1, 0, 0]);
+    expect([r, g, b].map((x) => +x.toFixed(4))).toEqual([0.2126, 0.2126, 0.2126]);
+    // Contrast pivots on mid grey: k = 2 doubles the distance from 0.5.
+    expect(adjustPixel({ contrast: 1 }, [0.5, 0.6, 0.3]).map((x) => +x.toFixed(3))).toEqual([0.5, 0.7, 0.1]);
+    // Brightness is a gain, clamped; warm lifts red and lowers blue by up to a fifth.
+    expect(adjustPixel({ brightness: 1 }, [0.25, 0.5, 0.75])).toEqual([0.5, 1, 1]);
+    expect(adjustPixel({ temperature: 1 }, [0.5, 0.5, 0.5]).map((x) => +x.toFixed(3))).toEqual([0.6, 0.5, 0.4]);
+    // Step 1 is one map, clamped once: saturation and contrast together.
+    // R: 0.5 * (0.2126 + 0.7874 * 2) + 0.25 = 1.144 -> 1; G, B: 0.5 * -0.2126 + 0.25.
+    expect(adjustPixel({ saturation: 1, contrast: -1 }, [1, 0, 0]).map((x) => +x.toFixed(4))).toEqual([1, 0.1437, 0.1437]);
+    // Temperature comes after step 1 is clamped: a clipped white turns warm.
+    expect(adjustPixel({ brightness: 1, temperature: 0.5 }, [0.8, 0.8, 0.8]).map((x) => +x.toFixed(3))).toEqual([1, 1, 0.9]);
+  });
+
+  it("goes with both halves of a split clip", () => {
+    const halves = splitClip({ trimStart: 0, duration: 10, adjust: { contrast: 0.2 } }, 4, 10, "b");
+    expect(halves?.map((h) => h.adjust)).toEqual([{ contrast: 0.2 }, { contrast: 0.2 }]);
+  });
+});
diff --git a/test/instruct.test.ts b/test/instruct.test.ts
index 1e63a1b..8375f56 100644
--- a/test/instruct.test.ts
+++ b/test/instruct.test.ts
@@ -80,6 +80,37 @@ describe("Ask operations", () => {
     expect(apply(d, "fade", { clip: 0 })).toHaveProperty("error");
   });
 
+  it("adjusts the colour of a clip, of every clip, and of an overlay", () => {
+    const d = edl();
+    d.overlays = [
+      {
+        id: "o",
+        elements: [
+          { id: "t", type: "text", text: "Hi", fontSize: 40, startTime: 0, duration: 2, x: 0.5, y: 0.5 },
+          { id: "l", type: "image", src: "asset:logo", startTime: 0, duration: 2, x: 0, y: 0, width: 0.2 },
+        ],
+      },
+    ];
+    expect(apply(d, "adjust_color", { clip: 0, contrast: 30, saturation: 250 })).toMatchObject({
+      said: "Set the colour of clip 0: contrast +30, saturation +100",
+    });
+    expect(d.main.elements[0].adjust).toEqual({ contrast: 0.3, saturation: 1 });
+    // Values left out stay; every clip gets the ones given.
+    expect(apply(d, "adjust_color", { every: true, temperature: -20 })).toHaveProperty("said");
+    expect(d.main.elements.map((e) => e.adjust)).toEqual([
+      { contrast: 0.3, saturation: 1, temperature: -0.2 },
+      { temperature: -0.2 },
+    ]);
+    // Back to 0 is back as shot: the field goes.
+    expect(apply(d, "adjust_color", { clip: 1, temperature: 0 })).toMatchObject({ said: "Put the colour of clip 1 back as shot" });
+    expect("adjust" in d.main.elements[1]).toBe(false);
+    expect(apply(d, "adjust_color", { track: 0, index: 1, brightness: -10 })).toHaveProperty("said");
+    expect(d.overlays[0].elements[1]).toMatchObject({ adjust: { brightness: -0.1 } });
+    expect(apply(d, "adjust_color", { track: 0, index: 0, brightness: 10 })).toHaveProperty("error");
+    expect(apply(d, "adjust_color", { clip: 0 })).toHaveProperty("error");
+    expect(apply(d, "adjust_color", { clip: 9, contrast: 10 })).toHaveProperty("error");
+  });
+
   it("joins one cut, or every cut, with a transition, and removes it with none", () => {
     const d = edl();
     d.main.elements.push({ id: "c", type: "image", src: "asset:three", duration: 3 });