@camstack/types 1.2.43 → 1.2.45

package/dist/capabilities/pipeline-analytics.cap.d.ts

@@ -247,6 +247,31 @@ export declare const TrackSourceSchema: z.ZodEnum<{
     pipeline: "pipeline";
 }>;
 export type TrackSource = z.infer<typeof TrackSourceSchema>;
+/**
+ * Where a track sits in the RETRAIN lifecycle (D81).
+ *
+ *  - `none` — never marked, or un-marked. Evictable.
+ *  - `staging` — the operator wants this track as training material and has not
+ *    finished with it. **This is the only state retention holds**: the track and
+ *    everything it owns (object events, crops, keyframes, CLIP vector) survive
+ *    the device's age window.
+ *  - `trained` — the retrain page has taken what it needed. The frames it chose
+ *    were COPIED into the retrain dataset at selection time, so the dataset no
+ *    longer depends on the track's media and the track becomes EVICTABLE again.
+ *    Terminal for the plain `markForTrain` toggle: returning it to `staging` is
+ *    a deliberate action of the retrain page, not a side effect of a checkbox.
+ *
+ * There is no `null`. The state is stored `TEXT NOT NULL DEFAULT 'none'` because
+ * the store's filter language has only positive equality and `whereIn` — no
+ * negation, no IS NULL — so a NULL would be unselectable by ANY predicate and
+ * would make the entire pre-column history immortal in one deploy.
+ */
+export declare const RetrainStatusSchema: z.ZodEnum<{
+    none: "none";
+    staging: "staging";
+    trained: "trained";
+}>;
+export type RetrainStatus = z.infer<typeof RetrainStatusSchema>;
 /**
  * The write half: a PARTIAL patch. An omitted key is left untouched, so setting
  * one flag can never clear the other — the toggles are independent and are
@@ -266,15 +291,83 @@ export declare const TrackFlagsSchema: z.ZodObject<{
     trackId: z.ZodString;
     markForTrain: z.ZodBoolean;
     debug: z.ZodBoolean;
+    retrainStatus: z.ZodEnum<{
+        none: "none";
+        staging: "staging";
+        trained: "trained";
+    }>;
 }, z.core.$strip>;
 export type TrackFlags = z.infer<typeof TrackFlagsSchema>;
+/**
+ * WHICH tier a label occupies. The slot a label lands in is DECLARED by the
+ * step that produced it (`StepDefinition.labelTier`), never inferred from the
+ * text or the step's name.
+ *
+ *  - `1` — a SUB-CLASS: finer than the macro class, still a taxonomy token.
+ *    `animal-type` (`dog`, `bird`), `vehicle-type` (`van`), and the root
+ *    detector's own raw class when it is finer than the macro it maps to.
+ *  - `2` — an INSTANCE: the finest thing said about this subject.
+ *    `species` (`Turdus migratorius`), `identity` (`Alice`), `plate-text`.
+ *
+ * The macro class itself (`person`, `vehicle`, `animal`, `package`, `face`,
+ * `plate`, `audio`) is NOT a tier — it is `className`, and a macro token
+ * offered for either label slot is refused (2026-08-07 rule; the refusal is
+ * logged as `label tier collapse refused`).
+ */
+export declare const LabelTierSchema: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+export type LabelTier = z.infer<typeof LabelTierSchema>;
+/**
+ * WHO decided a label, and when. Carried per tier so a value can be traced to
+ * the step and model that produced it — which is what makes the write rule
+ * arguable after the fact ("why is 592's label `dog` and not `Canis lupus`?")
+ * and what lets a migrated, UNATTRIBUTED value be told apart from a real one.
+ *
+ * `stepId` is the pipeline step id (`animal-classifier`, `bird-classifier`,
+ * `plate-ocr`, `face-embedding`, `object-detection`), or the sentinel
+ * `migration:4g` for a value the 4g migration moved from the single-slot era —
+ * that value has no provenance, and the write rule lets ANY properly-attributed
+ * write of the same tier replace it regardless of score.
+ */
+export declare const LabelAttributionSchema: z.ZodObject<{
+    stepId: z.ZodString;
+    modelId: z.ZodOptional<z.ZodString>;
+    decidedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type LabelAttribution = z.infer<typeof LabelAttributionSchema>;
+/** Per-camera slice of a training-export estimate. */
+export declare const TrainingExportDeviceTotalsSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    tracks: z.ZodNumber;
+    files: z.ZodNumber;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type TrainingExportDeviceTotals = z.infer<typeof TrainingExportDeviceTotalsSchema>;
+/**
+ * What a training export WOULD contain. Computed from media index rows only —
+ * no blob is read to produce this.
+ */
+export declare const TrainingExportSummarySchema: z.ZodObject<{
+    generatedAt: z.ZodNumber;
+    trackCount: z.ZodNumber;
+    fileCount: z.ZodNumber;
+    byteCount: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodNumber;
+        tracks: z.ZodNumber;
+        files: z.ZodNumber;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type TrainingExportSummary = z.infer<typeof TrainingExportSummarySchema>;
 declare const TrackSchema: z.ZodObject<{
+    retrainStatus: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        staging: "staging";
+        trained: "trained";
+    }>>;
     markForTrain: z.ZodOptional<z.ZodBoolean>;
     debug: z.ZodOptional<z.ZodBoolean>;
-    trackId: z.ZodString;
-    deviceId: z.ZodNumber;
-    className: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
     producingDeviceName: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodEnum<{
         sensor: "sensor";
@@ -336,6 +429,23 @@ declare const TrackSchema: z.ZodObject<{
         maxX: z.ZodNumber;
         maxY: z.ZodNumber;
     }, z.core.$strip>>;
+    label: z.ZodOptional<z.ZodString>;
+    labelScore: z.ZodOptional<z.ZodNumber>;
+    labelMeta: z.ZodOptional<z.ZodObject<{
+        stepId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        decidedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    subLabel: z.ZodOptional<z.ZodString>;
+    subLabelScore: z.ZodOptional<z.ZodNumber>;
+    subLabelMeta: z.ZodOptional<z.ZodObject<{
+        stepId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        decidedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    trackId: z.ZodString;
+    deviceId: z.ZodNumber;
+    className: z.ZodString;
 }, z.core.$strip>;
 export type Track = z.infer<typeof TrackSchema>;
 declare const MotionEventSchema: z.ZodObject<{
@@ -410,15 +520,6 @@ export declare const ZoneCrossingSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ZoneCrossing = z.infer<typeof ZoneCrossingSchema>;
 declare const ObjectEventSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"object">;
-    source: z.ZodOptional<z.ZodEnum<{
-        pipeline: "pipeline";
-        onboard: "onboard";
-    }>>;
-    frameId: z.ZodOptional<z.ZodString>;
-    trackId: z.ZodOptional<z.ZodString>;
-    className: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
     confidence: z.ZodOptional<z.ZodNumber>;
     bbox: z.ZodOptional<z.ZodObject<{
         x: z.ZodNumber;
@@ -448,6 +549,28 @@ declare const ObjectEventSchema: z.ZodObject<{
     keyFrameMediaKey: z.ZodOptional<z.ZodString>;
     mediaUrl: z.ZodOptional<z.ZodString>;
     importance: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
+    labelScore: z.ZodOptional<z.ZodNumber>;
+    labelMeta: z.ZodOptional<z.ZodObject<{
+        stepId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        decidedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    subLabel: z.ZodOptional<z.ZodString>;
+    subLabelScore: z.ZodOptional<z.ZodNumber>;
+    subLabelMeta: z.ZodOptional<z.ZodObject<{
+        stepId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        decidedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    kind: z.ZodLiteral<"object">;
+    source: z.ZodOptional<z.ZodEnum<{
+        pipeline: "pipeline";
+        onboard: "onboard";
+    }>>;
+    frameId: z.ZodOptional<z.ZodString>;
+    trackId: z.ZodOptional<z.ZodString>;
+    className: z.ZodString;
     id: z.ZodString;
     deviceId: z.ZodNumber;
     timestamp: z.ZodNumber;
@@ -536,6 +659,337 @@ declare const MediaFileInfoSchema: z.ZodObject<{
     sizeBytes: z.ZodNumber;
 }, z.core.$strip>;
 export type MediaFileInfo = z.infer<typeof MediaFileInfoSchema>;
+/**
+ * The MACRO tier of an annotation — a CLOSED set.
+ *
+ * This is what the exported detector predicts, so a typo here is a new class
+ * with one example in it. `label` and `subLabel` are open strings by contrast:
+ * the whole point of the page is teaching the model things it does not know
+ * yet, and constraining that vocabulary would make it useless.
+ *
+ * A macro class is NEVER a label. The provider refuses a write whose `label` or
+ * `subLabel` is one of these values, in any casing, because once `person`
+ * exists in both tiers "every person box" stops being answerable without
+ * knowing every string anyone ever typed — and the damage is retroactive.
+ */
+export declare const RetrainMacroClassSchema: z.ZodEnum<{
+    person: "person";
+    vehicle: "vehicle";
+    animal: "animal";
+    face: "face";
+    plate: "plate";
+    package: "package";
+}>;
+export type RetrainMacroClass = z.infer<typeof RetrainMacroClassSchema>;
+/** A subject to learn, or a phantom to unlearn (taught by OMISSION). */
+export declare const RetrainAnnotationKindSchema: z.ZodEnum<{
+    subject: "subject";
+    model_error: "model_error";
+}>;
+/** Did a human draw this box, or did the assist propose it? */
+export declare const RetrainAnnotationSourceSchema: z.ZodEnum<{
+    operator: "operator";
+    assist: "assist";
+}>;
+/**
+ * One annotated subject.
+ *
+ * `bbox` is normalised against the full frame, ALWAYS. The per-model shapes
+ * (letterboxed root / zone-cropped package / subject-cropped classifier) are
+ * derived from it at export and never stored — storing them is how one feature
+ * space ends up holding two crops of the same subject (D52).
+ */
+export declare const RetrainAnnotationSchema: z.ZodObject<{
+    id: z.ZodString;
+    trackId: z.ZodString;
+    deviceId: z.ZodNumber;
+    mediaKey: z.ZodString;
+    bbox: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+    macroClass: z.ZodEnum<{
+        person: "person";
+        vehicle: "vehicle";
+        animal: "animal";
+        face: "face";
+        plate: "plate";
+        package: "package";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+    subLabel: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        subject: "subject";
+        model_error: "model_error";
+    }>;
+    source: z.ZodEnum<{
+        operator: "operator";
+        assist: "assist";
+    }>;
+    assistModelId: z.ZodOptional<z.ZodString>;
+    assistScore: z.ZodOptional<z.ZodNumber>;
+    exportedInBatch: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+}, z.core.$strip>;
+export type RetrainAnnotation = z.infer<typeof RetrainAnnotationSchema>;
+/** The write form — the server owns `id`, `createdAt` and the frame binding. */
+export declare const RetrainAnnotationDraftSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        subject: "subject";
+        model_error: "model_error";
+    }>;
+    source: z.ZodEnum<{
+        operator: "operator";
+        assist: "assist";
+    }>;
+    bbox: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+    macroClass: z.ZodEnum<{
+        person: "person";
+        vehicle: "vehicle";
+        animal: "animal";
+        face: "face";
+        plate: "plate";
+        package: "package";
+    }>;
+    subLabel: z.ZodOptional<z.ZodString>;
+    assistModelId: z.ZodOptional<z.ZodString>;
+    assistScore: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RetrainAnnotationDraft = z.infer<typeof RetrainAnnotationDraftSchema>;
+/** A track sitting in `staging`, with everything the worklist needs to rank it. */
+export declare const RetrainTrackSchema: z.ZodObject<{
+    trackId: z.ZodString;
+    deviceId: z.ZodNumber;
+    className: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    firstSeen: z.ZodNumber;
+    lastSeen: z.ZodNumber;
+    frameCount: z.ZodNumber;
+    annotationCount: z.ZodNumber;
+}, z.core.$strip>;
+export type RetrainTrack = z.infer<typeof RetrainTrackSchema>;
+/** A frame the picker may offer — an index row, no blob was read to produce it. */
+export declare const RetrainFrameCandidateSchema: z.ZodObject<{
+    mediaKey: z.ZodString;
+    kind: z.ZodEnum<{
+        snapshot: "snapshot";
+        crop: "crop";
+        keyFrame: "keyFrame";
+        thumbnail: "thumbnail";
+        firstFrame: "firstFrame";
+        lastFrame: "lastFrame";
+        fullFrame: "fullFrame";
+        fullFrameBoxed: "fullFrameBoxed";
+        faceCrop: "faceCrop";
+        plateCrop: "plateCrop";
+        keyFrameSmall: "keyFrameSmall";
+        thumbnailSmall: "thumbnailSmall";
+    }>;
+    timestamp: z.ZodNumber;
+    sizeBytes: z.ZodNumber;
+    copied: z.ZodBoolean;
+}, z.core.$strip>;
+export type RetrainFrameCandidate = z.infer<typeof RetrainFrameCandidateSchema>;
+/** A frame the dataset OWNS: bytes copied at selection time. */
+export declare const RetrainFrameSchema: z.ZodObject<{
+    frameId: z.ZodString;
+    deviceId: z.ZodNumber;
+    trackId: z.ZodString;
+    sourceMediaKey: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        snapshot: "snapshot";
+        crop: "crop";
+        keyFrame: "keyFrame";
+        thumbnail: "thumbnail";
+        firstFrame: "firstFrame";
+        lastFrame: "lastFrame";
+        fullFrame: "fullFrame";
+        fullFrameBoxed: "fullFrameBoxed";
+        faceCrop: "faceCrop";
+        plateCrop: "plateCrop";
+        keyFrameSmall: "keyFrameSmall";
+        thumbnailSmall: "thumbnailSmall";
+    }>;
+    sizeBytes: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    copiedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type RetrainFrame = z.infer<typeof RetrainFrameSchema>;
+/** Why a copy-on-select could not be honoured — named, never a silent skip. */
+export declare const RetrainCopyRefusalSchema: z.ZodEnum<{
+    "source-missing": "source-missing";
+    "unreadable-image": "unreadable-image";
+    "write-failed": "write-failed";
+}>;
+export declare const RetrainFrameSelectionSchema: z.ZodObject<{
+    copied: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        frameId: z.ZodString;
+        deviceId: z.ZodNumber;
+        trackId: z.ZodString;
+        sourceMediaKey: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            snapshot: "snapshot";
+            crop: "crop";
+            keyFrame: "keyFrame";
+            thumbnail: "thumbnail";
+            firstFrame: "firstFrame";
+            lastFrame: "lastFrame";
+            fullFrame: "fullFrame";
+            fullFrameBoxed: "fullFrameBoxed";
+            faceCrop: "faceCrop";
+            plateCrop: "plateCrop";
+            keyFrameSmall: "keyFrameSmall";
+            thumbnailSmall: "thumbnailSmall";
+        }>;
+        sizeBytes: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        copiedAt: z.ZodNumber;
+    }, z.core.$strip>>>;
+    refused: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        sourceMediaKey: z.ZodString;
+        reason: z.ZodEnum<{
+            "source-missing": "source-missing";
+            "unreadable-image": "unreadable-image";
+            "write-failed": "write-failed";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RetrainFrameSelection = z.infer<typeof RetrainFrameSelectionSchema>;
+export declare const RetrainFrameListSchema: z.ZodObject<{
+    candidates: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        mediaKey: z.ZodString;
+        kind: z.ZodEnum<{
+            snapshot: "snapshot";
+            crop: "crop";
+            keyFrame: "keyFrame";
+            thumbnail: "thumbnail";
+            firstFrame: "firstFrame";
+            lastFrame: "lastFrame";
+            fullFrame: "fullFrame";
+            fullFrameBoxed: "fullFrameBoxed";
+            faceCrop: "faceCrop";
+            plateCrop: "plateCrop";
+            keyFrameSmall: "keyFrameSmall";
+            thumbnailSmall: "thumbnailSmall";
+        }>;
+        timestamp: z.ZodNumber;
+        sizeBytes: z.ZodNumber;
+        copied: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    copies: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        frameId: z.ZodString;
+        deviceId: z.ZodNumber;
+        trackId: z.ZodString;
+        sourceMediaKey: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            snapshot: "snapshot";
+            crop: "crop";
+            keyFrame: "keyFrame";
+            thumbnail: "thumbnail";
+            firstFrame: "firstFrame";
+            lastFrame: "lastFrame";
+            fullFrame: "fullFrame";
+            fullFrameBoxed: "fullFrameBoxed";
+            faceCrop: "faceCrop";
+            plateCrop: "plateCrop";
+            keyFrameSmall: "keyFrameSmall";
+            thumbnailSmall: "thumbnailSmall";
+        }>;
+        sizeBytes: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        copiedAt: z.ZodNumber;
+    }, z.core.$strip>>>;
+    autoPickMediaKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RetrainFrameList = z.infer<typeof RetrainFrameListSchema>;
+/** What the operator asked the assist to look for. */
+export declare const RetrainAssistSubjectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"package">;
+    zone: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"objects">;
+    modelId: z.ZodString;
+    minScore: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>], "kind">;
+/**
+ * The assist's answer — a discriminated union, because "the model saw nothing"
+ * and "this node cannot run that model" lead to different next moves and a
+ * nullable result cannot tell them apart.
+ */
+export declare const RetrainAssistResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"proposed">;
+    modelId: z.ZodString;
+    stepId: z.ZodString;
+    minScore: z.ZodNumber;
+    proposals: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            subject: "subject";
+            model_error: "model_error";
+        }>;
+        source: z.ZodEnum<{
+            operator: "operator";
+            assist: "assist";
+        }>;
+        bbox: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+        }, z.core.$strip>;
+        macroClass: z.ZodEnum<{
+            person: "person";
+            vehicle: "vehicle";
+            animal: "animal";
+            face: "face";
+            plate: "plate";
+            package: "package";
+        }>;
+        subLabel: z.ZodOptional<z.ZodString>;
+        assistModelId: z.ZodOptional<z.ZodString>;
+        assistScore: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    belowThreshold: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"refused">;
+    reason: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+export type RetrainAssistResult = z.infer<typeof RetrainAssistResultSchema>;
+/** The outcome of a lifecycle move owned by the retrain page. */
+export declare const RetrainTransitionResultSchema: z.ZodObject<{
+    trackId: z.ZodString;
+    retrainStatus: z.ZodEnum<{
+        none: "none";
+        staging: "staging";
+        trained: "trained";
+    }>;
+    changed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodEnum<{
+        unchanged: "unchanged";
+        "unknown-track": "unknown-track";
+        "no-frames-copied": "no-frames-copied";
+        "not-staging": "not-staging";
+        "not-trained": "not-trained";
+    }>>;
+}, z.core.$strip>;
+export type RetrainTransitionResult = z.infer<typeof RetrainTransitionResultSchema>;
 declare const RecentTracksQueryInput: z.ZodObject<{
     deviceIds: z.ZodArray<z.ZodNumber>;
     since: z.ZodOptional<z.ZodNumber>;
@@ -550,12 +1004,13 @@ declare const RecentTracksQueryInput: z.ZodObject<{
 export type RecentTracksQuery = z.infer<typeof RecentTracksQueryInput>;
 declare const RecentTracksPageSchema: z.ZodObject<{
     tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        retrainStatus: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            staging: "staging";
+            trained: "trained";
+        }>>;
         markForTrain: z.ZodOptional<z.ZodBoolean>;
         debug: z.ZodOptional<z.ZodBoolean>;
-        trackId: z.ZodString;
-        deviceId: z.ZodNumber;
-        className: z.ZodString;
-        label: z.ZodOptional<z.ZodString>;
         producingDeviceName: z.ZodOptional<z.ZodString>;
         source: z.ZodOptional<z.ZodEnum<{
             sensor: "sensor";
@@ -617,21 +1072,56 @@ declare const RecentTracksPageSchema: z.ZodObject<{
             maxX: z.ZodNumber;
             maxY: z.ZodNumber;
         }, z.core.$strip>>;
+        label: z.ZodOptional<z.ZodString>;
+        labelScore: z.ZodOptional<z.ZodNumber>;
+        labelMeta: z.ZodOptional<z.ZodObject<{
+            stepId: z.ZodString;
+            modelId: z.ZodOptional<z.ZodString>;
+            decidedAt: z.ZodNumber;
+        }, z.core.$strip>>;
+        subLabel: z.ZodOptional<z.ZodString>;
+        subLabelScore: z.ZodOptional<z.ZodNumber>;
+        subLabelMeta: z.ZodOptional<z.ZodObject<{
+            stepId: z.ZodString;
+            modelId: z.ZodOptional<z.ZodString>;
+            decidedAt: z.ZodNumber;
+        }, z.core.$strip>>;
+        trackId: z.ZodString;
+        deviceId: z.ZodNumber;
+        className: z.ZodString;
     }, z.core.$strip>>>;
     nextCursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type RecentTracksPage = z.infer<typeof RecentTracksPageSchema>;
 declare const KeyEventSchema: z.ZodObject<{
+    retrainStatus: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        staging: "staging";
+        trained: "trained";
+    }>>;
     markForTrain: z.ZodOptional<z.ZodBoolean>;
     debug: z.ZodOptional<z.ZodBoolean>;
+    importance: z.ZodNumber;
+    bestEventId: z.ZodString;
+    windowMs: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
+    labelScore: z.ZodOptional<z.ZodNumber>;
+    labelMeta: z.ZodOptional<z.ZodObject<{
+        stepId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        decidedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    subLabel: z.ZodOptional<z.ZodString>;
+    subLabelScore: z.ZodOptional<z.ZodNumber>;
+    subLabelMeta: z.ZodOptional<z.ZodObject<{
+        stepId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        decidedAt: z.ZodNumber;
+    }, z.core.$strip>>;
     id: z.ZodString;
     trackId: z.ZodString;
     timestamp: z.ZodNumber;
     className: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-    importance: z.ZodNumber;
-    bestEventId: z.ZodString;
-    windowMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type KeyEvent = z.infer<typeof KeyEventSchema>;
 declare const TrackedDetectionSchema: z.ZodObject<{
@@ -654,15 +1144,6 @@ declare const TrackedDetectionSchema: z.ZodObject<{
     }>;
 }, z.core.$strip>;
 export declare const ScoredObjectEventSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"object">;
-    source: z.ZodOptional<z.ZodEnum<{
-        pipeline: "pipeline";
-        onboard: "onboard";
-    }>>;
-    frameId: z.ZodOptional<z.ZodString>;
-    trackId: z.ZodOptional<z.ZodString>;
-    className: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
     confidence: z.ZodOptional<z.ZodNumber>;
     bbox: z.ZodOptional<z.ZodObject<{
         x: z.ZodNumber;
@@ -692,6 +1173,28 @@ export declare const ScoredObjectEventSchema: z.ZodObject<{
     keyFrameMediaKey: z.ZodOptional<z.ZodString>;
     mediaUrl: z.ZodOptional<z.ZodString>;
     importance: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
+    labelScore: z.ZodOptional<z.ZodNumber>;
+    labelMeta: z.ZodOptional<z.ZodObject<{
+        stepId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        decidedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    subLabel: z.ZodOptional<z.ZodString>;
+    subLabelScore: z.ZodOptional<z.ZodNumber>;
+    subLabelMeta: z.ZodOptional<z.ZodObject<{
+        stepId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        decidedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    kind: z.ZodLiteral<"object">;
+    source: z.ZodOptional<z.ZodEnum<{
+        pipeline: "pipeline";
+        onboard: "onboard";
+    }>>;
+    frameId: z.ZodOptional<z.ZodString>;
+    trackId: z.ZodOptional<z.ZodString>;
+    className: z.ZodString;
     id: z.ZodString;
     deviceId: z.ZodNumber;
     timestamp: z.ZodNumber;
@@ -744,12 +1247,13 @@ export declare const pipelineAnalyticsCapability: {
         readonly getActiveTracks: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            retrainStatus: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>>;
             markForTrain: z.ZodOptional<z.ZodBoolean>;
             debug: z.ZodOptional<z.ZodBoolean>;
-            trackId: z.ZodString;
-            deviceId: z.ZodNumber;
-            className: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
             producingDeviceName: z.ZodOptional<z.ZodString>;
             source: z.ZodOptional<z.ZodEnum<{
                 sensor: "sensor";
@@ -811,17 +1315,35 @@ export declare const pipelineAnalyticsCapability: {
                 maxX: z.ZodNumber;
                 maxY: z.ZodNumber;
             }, z.core.$strip>>;
+            label: z.ZodOptional<z.ZodString>;
+            labelScore: z.ZodOptional<z.ZodNumber>;
+            labelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            subLabel: z.ZodOptional<z.ZodString>;
+            subLabelScore: z.ZodOptional<z.ZodNumber>;
+            subLabelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            trackId: z.ZodString;
+            deviceId: z.ZodNumber;
+            className: z.ZodString;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly getTrack: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             trackId: z.ZodString;
         }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            retrainStatus: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>>;
             markForTrain: z.ZodOptional<z.ZodBoolean>;
             debug: z.ZodOptional<z.ZodBoolean>;
-            trackId: z.ZodString;
-            deviceId: z.ZodNumber;
-            className: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
             producingDeviceName: z.ZodOptional<z.ZodString>;
             source: z.ZodOptional<z.ZodEnum<{
                 sensor: "sensor";
@@ -883,6 +1405,23 @@ export declare const pipelineAnalyticsCapability: {
                 maxX: z.ZodNumber;
                 maxY: z.ZodNumber;
             }, z.core.$strip>>;
+            label: z.ZodOptional<z.ZodString>;
+            labelScore: z.ZodOptional<z.ZodNumber>;
+            labelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            subLabel: z.ZodOptional<z.ZodString>;
+            subLabelScore: z.ZodOptional<z.ZodNumber>;
+            subLabelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            trackId: z.ZodString;
+            deviceId: z.ZodNumber;
+            className: z.ZodString;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Historical completed tracks for a device. Queried from the
          *  persisted `pipeline-analytics:tracks` collection; active tracks
@@ -910,12 +1449,13 @@ export declare const pipelineAnalyticsCapability: {
                 slim: "slim";
             }>>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            retrainStatus: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>>;
             markForTrain: z.ZodOptional<z.ZodBoolean>;
             debug: z.ZodOptional<z.ZodBoolean>;
-            trackId: z.ZodString;
-            deviceId: z.ZodNumber;
-            className: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
             producingDeviceName: z.ZodOptional<z.ZodString>;
             source: z.ZodOptional<z.ZodEnum<{
                 sensor: "sensor";
@@ -977,6 +1517,23 @@ export declare const pipelineAnalyticsCapability: {
                 maxX: z.ZodNumber;
                 maxY: z.ZodNumber;
             }, z.core.$strip>>;
+            label: z.ZodOptional<z.ZodString>;
+            labelScore: z.ZodOptional<z.ZodNumber>;
+            labelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            subLabel: z.ZodOptional<z.ZodString>;
+            subLabelScore: z.ZodOptional<z.ZodNumber>;
+            subLabelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            trackId: z.ZodString;
+            deviceId: z.ZodNumber;
+            className: z.ZodString;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
          * Batched cluster-wide track listing — ONE call for the events page /
@@ -1000,12 +1557,13 @@ export declare const pipelineAnalyticsCapability: {
             }>>;
         }, z.core.$strip>, z.ZodObject<{
             tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                markForTrain: z.ZodOptional<z.ZodBoolean>;
-                debug: z.ZodOptional<z.ZodBoolean>;
-                trackId: z.ZodString;
-                deviceId: z.ZodNumber;
-                className: z.ZodString;
-                label: z.ZodOptional<z.ZodString>;
+                retrainStatus: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    staging: "staging";
+                    trained: "trained";
+                }>>;
+                markForTrain: z.ZodOptional<z.ZodBoolean>;
+                debug: z.ZodOptional<z.ZodBoolean>;
                 producingDeviceName: z.ZodOptional<z.ZodString>;
                 source: z.ZodOptional<z.ZodEnum<{
                     sensor: "sensor";
@@ -1067,6 +1625,23 @@ export declare const pipelineAnalyticsCapability: {
                     maxX: z.ZodNumber;
                     maxY: z.ZodNumber;
                 }, z.core.$strip>>;
+                label: z.ZodOptional<z.ZodString>;
+                labelScore: z.ZodOptional<z.ZodNumber>;
+                labelMeta: z.ZodOptional<z.ZodObject<{
+                    stepId: z.ZodString;
+                    modelId: z.ZodOptional<z.ZodString>;
+                    decidedAt: z.ZodNumber;
+                }, z.core.$strip>>;
+                subLabel: z.ZodOptional<z.ZodString>;
+                subLabelScore: z.ZodOptional<z.ZodNumber>;
+                subLabelMeta: z.ZodOptional<z.ZodObject<{
+                    stepId: z.ZodString;
+                    modelId: z.ZodOptional<z.ZodString>;
+                    decidedAt: z.ZodNumber;
+                }, z.core.$strip>>;
+                trackId: z.ZodString;
+                deviceId: z.ZodNumber;
+                className: z.ZodString;
             }, z.core.$strip>>>;
             nextCursor: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
@@ -1113,15 +1688,6 @@ export declare const pipelineAnalyticsCapability: {
             }>>;
             classFilter: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            kind: z.ZodLiteral<"object">;
-            source: z.ZodOptional<z.ZodEnum<{
-                pipeline: "pipeline";
-                onboard: "onboard";
-            }>>;
-            frameId: z.ZodOptional<z.ZodString>;
-            trackId: z.ZodOptional<z.ZodString>;
-            className: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
             confidence: z.ZodOptional<z.ZodNumber>;
             bbox: z.ZodOptional<z.ZodObject<{
                 x: z.ZodNumber;
@@ -1151,6 +1717,28 @@ export declare const pipelineAnalyticsCapability: {
             keyFrameMediaKey: z.ZodOptional<z.ZodString>;
             mediaUrl: z.ZodOptional<z.ZodString>;
             importance: z.ZodOptional<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
+            labelScore: z.ZodOptional<z.ZodNumber>;
+            labelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            subLabel: z.ZodOptional<z.ZodString>;
+            subLabelScore: z.ZodOptional<z.ZodNumber>;
+            subLabelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            kind: z.ZodLiteral<"object">;
+            source: z.ZodOptional<z.ZodEnum<{
+                pipeline: "pipeline";
+                onboard: "onboard";
+            }>>;
+            frameId: z.ZodOptional<z.ZodString>;
+            trackId: z.ZodOptional<z.ZodString>;
+            className: z.ZodString;
             id: z.ZodString;
             deviceId: z.ZodNumber;
             timestamp: z.ZodNumber;
@@ -1323,16 +1911,34 @@ export declare const pipelineAnalyticsCapability: {
             minImportance: z.ZodOptional<z.ZodNumber>;
             classFilter: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            retrainStatus: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>>;
             markForTrain: z.ZodOptional<z.ZodBoolean>;
             debug: z.ZodOptional<z.ZodBoolean>;
+            importance: z.ZodNumber;
+            bestEventId: z.ZodString;
+            windowMs: z.ZodOptional<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
+            labelScore: z.ZodOptional<z.ZodNumber>;
+            labelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            subLabel: z.ZodOptional<z.ZodString>;
+            subLabelScore: z.ZodOptional<z.ZodNumber>;
+            subLabelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
             id: z.ZodString;
             trackId: z.ZodString;
             timestamp: z.ZodNumber;
             className: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
-            importance: z.ZodNumber;
-            bestEventId: z.ZodString;
-            windowMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Server-side bucketed event counts for the 24-hour timeline.
          *  Returns one entry per non-empty bucket; empty buckets are omitted. */
@@ -1434,11 +2040,29 @@ export declare const pipelineAnalyticsCapability: {
          *
          * `auth: 'protected'` (the default), NOT `admin`: the viewer is an
          * authenticated non-admin surface and two of the three call sites are
-         * there. Revisit if a flag ever gains an effect that costs storage —
-         * `deleteTracks` next door is admin for exactly that reason.
+         * there. The note that used to sit here said to revisit this the day a flag
+         * gained an effect that costs storage, and D81 is that day — `markForTrain`
+         * now pins. It STAYS protected, and the reason is that the alternative
+         * makes the feature pointless: marking a track is something you do while
+         * looking at it, on the surface you were already looking at it on, and that
+         * surface is the viewer. What the storage cost gets instead is a BOUND — a
+         * per-device pin budget enforced in the body, refusing a new pin past the
+         * limit while always allowing un-marking. `deleteTracks` next door is still
+         * admin, because destroying evidence and preserving it are not symmetric.
+         *
+         * `markForTrain` writes the retrain LIFECYCLE, not a boolean column: `true`
+         * is `none → staging`, `false` is `staging → none`. A track already
+         * `trained` refuses BOTH — its frames are copies inside the retrain dataset
+         * and re-staging it from a generic toggle is how the same material gets
+         * annotated twice under two ground truths. Returning a trained track to
+         * staging is a deliberate action of the retrain page, which is also the only
+         * thing that produces `trained` in the first place.
          *
-         * Returns the RESOLVED state of both flags (absent → `false`) so a caller
-         * can drive its toggle without a re-fetch. Rejects an unknown track.
+         * Returns the RESOLVED state of both flags (absent → `false`) plus the
+         * `retrainStatus` they were derived from, so a caller can drive its toggle
+         * — and render a `trained` badge — without a re-fetch. Rejects an unknown
+         * track, a new staging mark on a device already holding its full budget, and
+         * any `markForTrain` write against a trained track.
          */
         readonly setTrackFlags: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
@@ -1451,6 +2075,11 @@ export declare const pipelineAnalyticsCapability: {
             trackId: z.ZodString;
             markForTrain: z.ZodBoolean;
             debug: z.ZodBoolean;
+            retrainStatus: z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>;
         }, z.core.$strip>, "mutation">;
         /**
          * Durable event-store footprint for the management UI: event rows
@@ -1570,6 +2199,482 @@ export declare const pipelineAnalyticsCapability: {
             detail: z.ZodNullable<z.ZodString>;
             actor: z.ZodString;
         }, z.core.$strip>>>, "query">;
+        /**
+         * The CHEAP QUESTION, asked before any media moves: how big is the dataset
+         * the marked (`markForTrain`) tracks would produce?
+         *
+         * Answered from media INDEX rows only — key, kind, size, timestamp — so it
+         * costs ~2 KB of reads per track and no blob reads at all. The measured harm
+         * behind D56 was a bulk pass that read and base64'd every blob a track owned
+         * before deciding anything, taking hub-main to 82 s busy out of 120; an
+         * export is that same I/O shape, so it inherits the same discipline: know
+         * the size, then decide.
+         *
+         * `truncated` reports that more marked tracks exist than one pass carries.
+         * Empty `deviceIds` ⇒ every device that has marked tracks.
+         */
+        readonly getTrainingExportSummary: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>, z.ZodObject<{
+            generatedAt: z.ZodNumber;
+            trackCount: z.ZodNumber;
+            fileCount: z.ZodNumber;
+            byteCount: z.ZodNumber;
+            truncated: z.ZodBoolean;
+            devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                tracks: z.ZodNumber;
+                files: z.ZodNumber;
+                bytes: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, "query">;
+        /**
+         * Where to download the dataset archive.
+         *
+         * The BYTES do not come back through this cap — they come from the returned
+         * data-plane URL, which streams a tar built entry by entry. A multi-gigabyte
+         * archive base64'd through a unary RPC envelope would be held whole in
+         * memory twice on a hub this repo has already OOM'd once (D9/D18 are the
+         * same lesson about frames). `getDownloadUrl` on `recordingExport` is the
+         * precedent, and this follows it deliberately.
+         *
+         * The archive contains a `manifest.json` FIRST, then the stored media
+         * VERBATIM under `tracks/<deviceId>/<trackId>/…`. No crop is derived and no
+         * model is run: a training set's pixels must be the pixels the pipeline saw.
+         */
+        readonly getTrainingExportUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>, z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strip>, "query">;
+        /**
+         * The staging worklist for one camera, or for every camera that has one.
+         *
+         * Fetched ON DEMAND, over the staging set only — the page never scans
+         * history, because making the working set small is the entire purpose of
+         * the mark. Each row carries how many frames the dataset already holds from
+         * the track and how many subjects were annotated on them, so
+         * `frameCount: 0` reads as "still to work" without a second call per track.
+         *
+         * `auth: 'admin'`, unlike the viewer-level mark itself: marking a track is
+         * curation you do while looking at it, but building the training set the
+         * fleet's models are fine-tuned on is not.
+         */
+        readonly listRetrainStaging: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            trackId: z.ZodString;
+            deviceId: z.ZodNumber;
+            className: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            firstSeen: z.ZodNumber;
+            lastSeen: z.ZodNumber;
+            frameCount: z.ZodNumber;
+            annotationCount: z.ZodNumber;
+        }, z.core.$strip>>>, "query">;
+        /**
+         * What a track can contribute, and what it already has.
+         *
+         * `candidates` are the track's whole, unannotated frames — index rows only,
+         * so this is cheap. `copies` are the frames already inside the dataset, and
+         * a candidate whose copy exists is marked `copied: true`: selecting it again
+         * is free and CANNOT fail, whatever became of the original.
+         *
+         * A crop, a thumbnail and `fullFrameBoxed` are never candidates. The last
+         * one matters most: it has the model's own rectangle burned into the pixels,
+         * and a detector trained on it learns to find a green line.
+         */
+        readonly listRetrainFrames: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            trackId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            candidates: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                mediaKey: z.ZodString;
+                kind: z.ZodEnum<{
+                    snapshot: "snapshot";
+                    crop: "crop";
+                    keyFrame: "keyFrame";
+                    thumbnail: "thumbnail";
+                    firstFrame: "firstFrame";
+                    lastFrame: "lastFrame";
+                    fullFrame: "fullFrame";
+                    fullFrameBoxed: "fullFrameBoxed";
+                    faceCrop: "faceCrop";
+                    plateCrop: "plateCrop";
+                    keyFrameSmall: "keyFrameSmall";
+                    thumbnailSmall: "thumbnailSmall";
+                }>;
+                timestamp: z.ZodNumber;
+                sizeBytes: z.ZodNumber;
+                copied: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            copies: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                frameId: z.ZodString;
+                deviceId: z.ZodNumber;
+                trackId: z.ZodString;
+                sourceMediaKey: z.ZodString;
+                sourceKind: z.ZodEnum<{
+                    snapshot: "snapshot";
+                    crop: "crop";
+                    keyFrame: "keyFrame";
+                    thumbnail: "thumbnail";
+                    firstFrame: "firstFrame";
+                    lastFrame: "lastFrame";
+                    fullFrame: "fullFrame";
+                    fullFrameBoxed: "fullFrameBoxed";
+                    faceCrop: "faceCrop";
+                    plateCrop: "plateCrop";
+                    keyFrameSmall: "keyFrameSmall";
+                    thumbnailSmall: "thumbnailSmall";
+                }>;
+                sizeBytes: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+                copiedAt: z.ZodNumber;
+            }, z.core.$strip>>>;
+            autoPickMediaKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, "query">;
+        /**
+         * COPY-ON-SELECT — the write that makes `trained` safe to evict.
+         *
+         * Selecting a frame copies its bytes into retrain storage immediately: not
+         * a reference, not a lease. Once the copy exists the dataset no longer
+         * depends on the track's media, which is exactly what lets D81 hand a
+         * `trained` track back to retention.
+         *
+         * The order inside is load-bearing and is pinned by a test: an EXISTING
+         * copy is returned without touching the source, so an original that
+         * evaporated blocks the selection of THAT ORIGINAL and never the copy
+         * already taken. Every refusal comes back named — a dropped selection is
+         * never silent, on the wire or in the log.
+         */
+        readonly selectRetrainFrames: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            trackId: z.ZodString;
+            mediaKeys: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            copied: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                frameId: z.ZodString;
+                deviceId: z.ZodNumber;
+                trackId: z.ZodString;
+                sourceMediaKey: z.ZodString;
+                sourceKind: z.ZodEnum<{
+                    snapshot: "snapshot";
+                    crop: "crop";
+                    keyFrame: "keyFrame";
+                    thumbnail: "thumbnail";
+                    firstFrame: "firstFrame";
+                    lastFrame: "lastFrame";
+                    fullFrame: "fullFrame";
+                    fullFrameBoxed: "fullFrameBoxed";
+                    faceCrop: "faceCrop";
+                    plateCrop: "plateCrop";
+                    keyFrameSmall: "keyFrameSmall";
+                    thumbnailSmall: "thumbnailSmall";
+                }>;
+                sizeBytes: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+                copiedAt: z.ZodNumber;
+            }, z.core.$strip>>>;
+            refused: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                sourceMediaKey: z.ZodString;
+                reason: z.ZodEnum<{
+                    "source-missing": "source-missing";
+                    "unreadable-image": "unreadable-image";
+                    "write-failed": "write-failed";
+                }>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, "mutation">;
+        /** Un-select a frame: its annotations go first, then the copy and its blob.
+         *  Deliberately destructive and deliberately explicit — it is the only way
+         *  a frame leaves the dataset before export. */
+        readonly deselectRetrainFrame: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            trackId: z.ZodString;
+            frameId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            removed: z.ZodBoolean;
+            removedAnnotations: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * The pixels of ONE copied frame, base64.
+         *
+         * Through the cap rather than a data plane because it is genuinely one
+         * frame at a time, on demand, at human speed — the shape D9/D18 permit
+         * (what they forbid is frames crossing a boundary at frame RATE). The
+         * annotation canvas needs the image and its exact dimensions in the same
+         * answer: a canvas that places a normalised box against a size it guessed
+         * draws every box in the wrong place.
+         */
+        readonly getRetrainFrameImage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            frameId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            base64: z.ZodString;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>, "query">;
+        /**
+         * Ask the pipeline what it sees, as a PROPOSAL.
+         *
+         * Runs through `pipelineRunner.runStatelessStep` on the COPIED frame, and
+         * every box comes back as a draft with `source: 'assist'` plus the model and
+         * score that produced it. The operator confirms, edits, adds and deletes;
+         * nothing is stored until `saveRetrainAnnotations`.
+         *
+         * For packages the request is `rfdetr-package` on the ZONE CROP at 0.35 —
+         * never the whole frame, where a package detector at that threshold proposes
+         * furniture. A package request with no zone is REFUSED rather than widened,
+         * because the silent widening would look like a bad model for as long as
+         * nobody checked which rectangle it ran on.
+         */
+        readonly proposeRetrainAnnotations: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            trackId: z.ZodString;
+            frameId: z.ZodString;
+            subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"package">;
+                zone: z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"objects">;
+                modelId: z.ZodString;
+                minScore: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>], "kind">;
+            nodeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"proposed">;
+            modelId: z.ZodString;
+            stepId: z.ZodString;
+            minScore: z.ZodNumber;
+            proposals: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                label: z.ZodOptional<z.ZodString>;
+                kind: z.ZodEnum<{
+                    subject: "subject";
+                    model_error: "model_error";
+                }>;
+                source: z.ZodEnum<{
+                    operator: "operator";
+                    assist: "assist";
+                }>;
+                bbox: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                }, z.core.$strip>;
+                macroClass: z.ZodEnum<{
+                    person: "person";
+                    vehicle: "vehicle";
+                    animal: "animal";
+                    face: "face";
+                    plate: "plate";
+                    package: "package";
+                }>;
+                subLabel: z.ZodOptional<z.ZodString>;
+                assistModelId: z.ZodOptional<z.ZodString>;
+                assistScore: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            belowThreshold: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"refused">;
+            reason: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "kind">, "mutation">;
+        /** Every annotation on a track, oldest first. */
+        readonly listRetrainAnnotations: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            trackId: z.ZodString;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            trackId: z.ZodString;
+            deviceId: z.ZodNumber;
+            mediaKey: z.ZodString;
+            bbox: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                w: z.ZodNumber;
+                h: z.ZodNumber;
+            }, z.core.$strip>;
+            macroClass: z.ZodEnum<{
+                person: "person";
+                vehicle: "vehicle";
+                animal: "animal";
+                face: "face";
+                plate: "plate";
+                package: "package";
+            }>;
+            label: z.ZodOptional<z.ZodString>;
+            subLabel: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                subject: "subject";
+                model_error: "model_error";
+            }>;
+            source: z.ZodEnum<{
+                operator: "operator";
+                assist: "assist";
+            }>;
+            assistModelId: z.ZodOptional<z.ZodString>;
+            assistScore: z.ZodOptional<z.ZodNumber>;
+            exportedInBatch: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodNumber;
+        }, z.core.$strip>>>, "query">;
+        /**
+         * Replace EVERY annotation on one frame with the supplied set.
+         *
+         * Whole-frame replacement, not per-box upsert: the unit of ground truth is
+         * the frame, and "the operator deleted a box" must be the same durable
+         * outcome as "the operator never drew it". A per-box patch would let a frame
+         * keep a box the operator removed on a surface that only knew about the
+         * boxes it sent.
+         *
+         * Refuses a macro class typed into `label` or `subLabel` — the tiers are
+         * separate and the guard is at the WRITE, because a mixed taxonomy cannot
+         * be un-mixed by reading it.
+         */
+        readonly saveRetrainAnnotations: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            trackId: z.ZodString;
+            frameId: z.ZodString;
+            annotations: z.ZodArray<z.ZodObject<{
+                label: z.ZodOptional<z.ZodString>;
+                kind: z.ZodEnum<{
+                    subject: "subject";
+                    model_error: "model_error";
+                }>;
+                source: z.ZodEnum<{
+                    operator: "operator";
+                    assist: "assist";
+                }>;
+                bbox: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                }, z.core.$strip>;
+                macroClass: z.ZodEnum<{
+                    person: "person";
+                    vehicle: "vehicle";
+                    animal: "animal";
+                    face: "face";
+                    plate: "plate";
+                    package: "package";
+                }>;
+                subLabel: z.ZodOptional<z.ZodString>;
+                assistModelId: z.ZodOptional<z.ZodString>;
+                assistScore: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            trackId: z.ZodString;
+            deviceId: z.ZodNumber;
+            mediaKey: z.ZodString;
+            bbox: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                w: z.ZodNumber;
+                h: z.ZodNumber;
+            }, z.core.$strip>;
+            macroClass: z.ZodEnum<{
+                person: "person";
+                vehicle: "vehicle";
+                animal: "animal";
+                face: "face";
+                plate: "plate";
+                package: "package";
+            }>;
+            label: z.ZodOptional<z.ZodString>;
+            subLabel: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                subject: "subject";
+                model_error: "model_error";
+            }>;
+            source: z.ZodEnum<{
+                operator: "operator";
+                assist: "assist";
+            }>;
+            assistModelId: z.ZodOptional<z.ZodString>;
+            assistScore: z.ZodOptional<z.ZodNumber>;
+            exportedInBatch: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodNumber;
+        }, z.core.$strip>>>, "mutation">;
+        /**
+         * Finish with a track: `staging → trained`. **The only writer of that
+         * state** — D81 shipped the column with it deliberately unreachable.
+         *
+         * Refuses a track the dataset holds no copies from. `trained` un-pins the
+         * track's media, so completing without a copy is a delete order for material
+         * nothing ever extracted anything from; that refusal IS the safety argument
+         * of D81, expressed as a precondition.
+         */
+        readonly completeRetrainTrack: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            trackId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            trackId: z.ZodString;
+            retrainStatus: z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>;
+            changed: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodEnum<{
+                unchanged: "unchanged";
+                "unknown-track": "unknown-track";
+                "no-frames-copied": "no-frames-copied";
+                "not-staging": "not-staging";
+                "not-trained": "not-trained";
+            }>>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * The deliberate return: `trained → staging`, for the rare case.
+         *
+         * The generic `setTrackFlags` toggle refuses this in both directions by
+         * design (D81) — re-staging from a checkbox is how the same material gets
+         * annotated twice under two ground truths. Doing it here means the operator
+         * is looking at the annotations that already exist while they decide, and
+         * those annotations are LEFT ALONE: "put this back" must not be a
+         * destructive act wearing a navigational name.
+         */
+        readonly restageRetrainTrack: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            trackId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            trackId: z.ZodString;
+            retrainStatus: z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>;
+            changed: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodEnum<{
+                unchanged: "unchanged";
+                "unknown-track": "unknown-track";
+                "no-frames-copied": "no-frames-copied";
+                "not-staging": "not-staging";
+                "not-trained": "not-trained";
+            }>>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Where to download the ANNOTATED dataset.
+         *
+         * The sibling of `getTrainingExportUrl` and deliberately not the same
+         * archive: that one streams a marked track's stored media verbatim, this one
+         * streams the retrain COPIES plus an `annotations.json` carrying, for every
+         * subject, the canonical full-frame box AND the geometry derived for each
+         * model shape (letterboxed root / zone-cropped package / subject-cropped
+         * classifier). Derived at export, never stored — one box in, three shapes
+         * out, so two crops of the same subject can never end up in one feature
+         * space (D52).
+         */
+        readonly getRetrainExportUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>, z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strip>, "query">;
         readonly getEventMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             eventId: z.ZodString;
             kind: z.ZodOptional<z.ZodEnum<{
@@ -1699,15 +2804,6 @@ export declare const pipelineAnalyticsCapability: {
             limit: z.ZodDefault<z.ZodNumber>;
             minScore: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            kind: z.ZodLiteral<"object">;
-            source: z.ZodOptional<z.ZodEnum<{
-                pipeline: "pipeline";
-                onboard: "onboard";
-            }>>;
-            frameId: z.ZodOptional<z.ZodString>;
-            trackId: z.ZodOptional<z.ZodString>;
-            className: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
             confidence: z.ZodOptional<z.ZodNumber>;
             bbox: z.ZodOptional<z.ZodObject<{
                 x: z.ZodNumber;
@@ -1737,6 +2833,28 @@ export declare const pipelineAnalyticsCapability: {
             keyFrameMediaKey: z.ZodOptional<z.ZodString>;
             mediaUrl: z.ZodOptional<z.ZodString>;
             importance: z.ZodOptional<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
+            labelScore: z.ZodOptional<z.ZodNumber>;
+            labelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            subLabel: z.ZodOptional<z.ZodString>;
+            subLabelScore: z.ZodOptional<z.ZodNumber>;
+            subLabelMeta: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodOptional<z.ZodString>;
+                decidedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            kind: z.ZodLiteral<"object">;
+            source: z.ZodOptional<z.ZodEnum<{
+                pipeline: "pipeline";
+                onboard: "onboard";
+            }>>;
+            frameId: z.ZodOptional<z.ZodString>;
+            trackId: z.ZodOptional<z.ZodString>;
+            className: z.ZodString;
             id: z.ZodString;
             deviceId: z.ZodNumber;
             timestamp: z.ZodNumber;