@scalebrowser/sdk 1.1.0 → 1.3.0

package/dist/index.d.cts

@@ -105,6 +105,74 @@ interface Persona {
     misc: PersonaMisc;
 }
 
+/** What kind of file a media asset is. */
+type MediaKind = 'image' | 'music' | 'subtitle_style';
+/** One uploaded file a preset refers to by id. */
+interface MediaAsset {
+    id: string;
+    kind: MediaKind;
+    name: string;
+    mime: string;
+    bytes: number;
+    /** The content's checksum. It is also the file name on disk, so the same
+     *  bytes are stored once however often they are uploaded. */
+    sha256: string;
+    created_at: number;
+}
+/** A speech provider that has a key stored.
+ *
+ *  There is deliberately no `api_key` here: the daemon answers with a hint and
+ *  never with the value. A client that could read it back would be the one
+ *  place it lands in a log again. */
+interface TtsProviderView {
+    provider: 'elevenlabs' | 'fish_audio' | 'openai';
+    /** The last few characters, never more. */
+    key_hint: string;
+    label: string | null;
+    verified_at: number | null;
+    updated_at: number;
+}
+/** What one real call to the provider proved.
+ *
+ *  A stored key and a working key are two things, so this speaks a short word
+ *  and reports what came back. Only an answer that carried both audio and word
+ *  timings counts: a 200 with an empty body proves nothing.
+ */
+interface TtsVerifyResult {
+    provider: 'elevenlabs' | 'fish_audio' | 'openai';
+    /** Unix seconds. The same value the provider row now carries. */
+    verified_at: number;
+    wav_bytes: number;
+    words: number;
+}
+/** Where a share link stands ON THIS MACHINE: an order, not a copy.
+ *
+ *  `outbox` is what is still owed: `pending` while the files are going up,
+ *  `live` once the control plane confirmed, `revoke_pending` after a revoke that
+ *  has not been acknowledged yet. A revoke-pending link STILL BLOCKS: between
+ *  the order and the confirmation the page may still answer. */
+interface ShareLinkLocal {
+    link_id: string;
+    url: string;
+    version: number;
+    outbox: 'pending' | 'live' | 'revoke_pending';
+    /** Whether the link asks for an access code. Never the code itself. */
+    passcode: boolean;
+    download: boolean;
+    updated_at: number;
+    error: string | null;
+}
+/** `GET /v1/videos/:id/share`: the order, and the link's access code when this
+ *  machine keeps one (sealed at rest). A link the daemon makes for a preset with
+ *  `export.destination.passcode` gets a generated code of ten characters, and
+ *  this is where its owner reads it. `Video.share`, `video_changed` and the
+ *  `video` tool never carry the code. */
+interface ShareStatus extends ShareLinkLocal {
+    /** Absent when this machine keeps no code: the link has none, or its
+     *  revocation is ordered. */
+    code?: string;
+}
+
 type RecordingKind = 'showcase' | 'proof';
 type RecordingState = 'recording' | 'finishing' | 'finished' | 'failed';
 type VideoState = 'queued' | 'rendering' | 'done' | 'failed' | 'cancelled';
@@ -343,76 +411,347 @@ interface BlockedExport {
     export: ExportPresetName;
     reason: string;
 }
-/** What kind of file a media asset is. */
-type MediaKind = 'image' | 'music' | 'subtitle_style';
-/** One uploaded file a preset refers to by id. */
-interface MediaAsset {
-    id: string;
-    kind: MediaKind;
-    name: string;
-    mime: string;
-    bytes: number;
-    /** The content's checksum. It is also the file name on disk, so the same
-     *  bytes are stored once however often they are uploaded. */
-    sha256: string;
-    created_at: number;
+
+/** What lies behind the page: a gradient, a colour, an image, or nothing. */
+type VideoBackground = {
+    kind: 'gradient';
+    colors: string[];
+} | {
+    kind: 'solid';
+    color: string;
+} | {
+    kind: 'image';
+    media_id: string;
+} | {
+    kind: 'none';
+};
+/** Intro and outro. `hold_result` holds the last frame instead of a card. */
+type VideoCard = {
+    style: 'title_card';
+    seconds: number;
+} | {
+    style: 'hold_result';
+    seconds: number;
+};
+/** Where the finished video goes. */
+type VideoDestination = {
+    kind: 'local';
+} | {
+    kind: 'link';
+    expires_days: number | null;
+    download: boolean;
+    passcode: boolean;
+};
+/** An additional output with its own dimensions. Objects, never bare strings. */
+interface ExtraOutput {
+    preset: ExportPresetName;
+    width?: number | null;
+    height?: number | null;
+    fps?: number | null;
+    colors?: number | null;
+    max_bytes?: number | null;
 }
-/** A speech provider that has a key stored.
- *
- *  There is deliberately no `api_key` here: the daemon answers with a hint and
- *  never with the value. A client that could read it back would be the one
- *  place it lands in a log again. */
-interface TtsProviderView {
-    provider: 'elevenlabs' | 'fish_audio' | 'openai';
-    /** The last few characters, never more. */
-    key_hint: string;
-    label: string | null;
-    verified_at: number | null;
-    updated_at: number;
+/** Background music, by media id, with its level. */
+interface MusicBed {
+    media_id: string;
+    gain_db: number;
 }
-/** What one real call to the provider proved.
+/**
+ * The recipe of a video: everything about the FORM, nothing about the content.
  *
- *  A stored key and a working key are two things, so this speaks a short word
- *  and reports what came back. Only an answer that carried both audio and word
- *  timings counts: a 200 with an empty body proves nothing.
+ * Steps, length, title and narration come from the request, never from here;
+ * the only free text field is `ai_label.text`.
  */
-interface TtsVerifyResult {
-    provider: 'elevenlabs' | 'fish_audio' | 'openai';
-    /** Unix seconds. The same value the provider row now carries. */
-    verified_at: number;
-    wav_bytes: number;
-    words: number;
+interface VideoPresetConfig {
+    output: {
+        aspect: '16:9' | '9:16' | '1:1';
+        resolution: '720p' | '1080p' | '4k';
+        fps: number;
+    };
+    frame: {
+        background: VideoBackground;
+        padding_pct: number;
+        corner_radius_px: number;
+        shadow: 'none' | 'soft' | 'hard';
+        inset_px: number;
+        window_chrome: 'none' | 'plain' | 'address_bar';
+    };
+    cursor: {
+        scale: number;
+        style: 'arrow_dark' | 'arrow_light' | 'dot' | 'touch';
+        click: 'ripple' | 'ring' | 'none';
+        /** `null` keeps the pointer visible forever. */
+        hide_after_ms: number | null;
+        loop: boolean;
+    };
+    camera: {
+        zoom: 'off' | 'gentle' | 'medium' | 'strong';
+        motion_blur: boolean;
+        tightening: 'none' | 'normal' | 'strong';
+        ride: 'calm' | 'standard' | 'brisk';
+        zoom_scope: 'canvas' | 'card';
+    };
+    audio: {
+        /** `"<provider>:<voice>"`, or `null` for a silent video. */
+        voice: string | null;
+        language: string;
+        subtitles: 'burned' | 'file' | 'off';
+        /** `custom:<media_id>` names an uploaded font (media kind `subtitle_style`). */
+        subtitle_style: 'classic' | 'word' | `custom:${string}`;
+        page_audio: boolean;
+        music: MusicBed | null;
+    };
+    cards: {
+        intro: VideoCard | null;
+        outro: VideoCard | null;
+    };
+    masking: {
+        level: 'off' | 'secrets' | 'secrets_and_ids';
+        style: 'bar' | 'pixelate' | 'blur' | 'placeholder';
+    };
+    export: {
+        preset: ExportPresetName;
+        also: ExtraOutput[];
+        destination: VideoDestination;
+    };
+    ai_label: {
+        enabled: boolean;
+        text: string;
+        position: 'top_left' | 'top_right' | 'bottom_left' | 'bottom_right';
+    };
 }
-/** Where a share link stands ON THIS MACHINE: an order, not a copy.
+/**
+ * A video RECIPE: how a recording becomes a video (`/v1/video-presets`).
  *
- *  `outbox` is what is still owed: `pending` while the files are going up,
- *  `live` once the control plane confirmed, `revoke_pending` after a revoke that
- *  has not been acknowledged yet. A revoke-pending link STILL BLOCKS: between
- *  the order and the confirmation the page may still answer. */
-interface ShareLinkLocal {
-    link_id: string;
-    url: string;
-    version: number;
-    outbox: 'pending' | 'live' | 'revoke_pending';
-    /** Whether the link asks for an access code. Never the code itself. */
-    passcode: boolean;
-    download: boolean;
+ * `config` was an open object for a long time, on the argument that a second
+ * TypeScript copy of a two-dozen-enum schema is a second place for it to rot.
+ * The copy exists now because a form over an open object is a pile of casts and
+ * a typo in it only surfaces as a 400 after somebody pressed save; what took
+ * the argument's teeth is that the copy is held against the Rust source field
+ * by field (`preset-schema-mirror`), so it cannot rot quietly.
+ */
+interface VideoPreset {
+    id: string;
+    name: string;
+    /** Shipped with the product; can be duplicated but not edited or deleted. */
+    builtin: boolean;
+    config: VideoPresetConfig;
+    created_at: number;
     updated_at: number;
-    error: string | null;
 }
-/** `GET /v1/videos/:id/share`: the order, and the link's access code when this
- *  machine keeps one (sealed at rest). A link the daemon makes for a preset with
- *  `export.destination.passcode` gets a generated code of ten characters, and
- *  this is where its owner reads it. `Video.share`, `video_changed` and the
- *  `video` tool never carry the code. */
-interface ShareStatus extends ShareLinkLocal {
-    /** Absent when this machine keeps no code: the link has none, or its
-     *  revocation is ordered. */
-    code?: string;
+/** One named frame of the sample film the preview can jump to, with the clip window around it. */
+interface PreviewMoment {
+    key: string;
+    label: string;
+    frame: number;
+    from: number;
+    to: number;
 }
-
-/**
- * Wire types: a 1:1 mirror of the daemon's serialized domain model and of the
+/** A preset field the sample film cannot show, and why. */
+interface PreviewHidden {
+    field: string;
+    why: string;
+}
+/** `POST /v1/video-presets/preview`: one still of the sample film under an unsaved config. */
+interface VideoPresetPreviewBody {
+    config: VideoPresetConfig;
+    frame?: number;
+    moment?: string;
+    name?: string;
+    /** Draw at this short side instead of the recipe's own, 360 to 2160. */
+    proxy_short_side?: number;
+}
+/** The reply: the picture as a data URL plus what the film looks like under this config. */
+interface VideoPresetPreview {
+    width: number;
+    height: number;
+    fps: number;
+    frames: number;
+    frame: number;
+    moments: PreviewMoment[];
+    hidden: PreviewHidden[];
+    notes: string[];
+    image: string;
+}
+/** `POST /v1/video-presets/preview/clip`: frames `from_frame..to_frame` of the sample film as an MP4. */
+interface VideoPresetClipBody {
+    config: VideoPresetConfig;
+    /** Absent means the start of the film. */
+    from_frame?: number;
+    /** Exclusive; absent means the end of the film. */
+    to_frame?: number;
+    name?: string;
+    /** Draw at this short side instead of the recipe's own, 360 to 2160. */
+    proxy_short_side?: number;
+}
+/** One progress frame of the clip's SSE stream (`event: progress`). */
+interface VideoPresetClipProgress {
+    done: number;
+    total: number;
+}
+/**
+ * `event: started`, the FIRST frame of the SSE answer: the id under which the
+ * bytes can already be followed (`?follow=1`), and the shape of the film.
+ *
+ * It exists so a player can begin while the render still runs. Without it the
+ * id arrives with `done`, and by then there is nothing left to follow.
+ */
+interface VideoPresetClipStarted {
+    id: string;
+    frames: number;
+    fps: number;
+    width: number;
+    height: number;
+}
+/** The finished clip (`event: done`, or the blocking JSON reply); the bytes come from `GET /v1/video-presets/preview/clip/:id`. */
+interface VideoPresetClip {
+    id: string;
+    from_frame: number;
+    to_frame: number;
+    fps: number;
+    width: number;
+    height: number;
+    frames: number;
+    seconds: number;
+    bytes: number;
+    encoder: string;
+    cached: boolean;
+    audio: boolean;
+}
+
+/** `ProxyKind`. */
+type ProxyKind = 'http' | 'socks5' | 'gateway';
+declare const PROXY_KINDS: readonly ProxyKind[];
+/** `Rotation`. */
+type Rotation = 'sticky' | 'rotating';
+declare const ROTATIONS: readonly Rotation[];
+/** Proxy; credentials are write-only (`#[serde(skip_serializing)]`) and never returned. */
+interface Proxy {
+    id: string;
+    kind: ProxyKind;
+    host: string;
+    port: number;
+    rotation: Rotation;
+    /**
+     * The operator's own name for this row, or `null` if they never gave one.
+     *
+     * The only field that tells two rows of one provider pool apart: kind, host,
+     * port and rotation are identical across a bought gateway, and the session tag
+     * that actually differs sits in the write-only username. Do not fall back to
+     * `last_exit_ip` for identity; the health check wrote it hours or days ago and
+     * a rotating exit no longer has that address.
+     */
+    label: string | null;
+    last_exit_ip: string | null;
+    last_country: string | null;
+    /**
+     * The operator string the geo probe answered with, for example
+     * `"AS21928 T-Mobile USA, Inc."`. Part of the same measurement as the fields
+     * around it: one check writes them, an endpoint change clears them together.
+     * The daemon derives the address kind from it, which decides how long an
+     * address stays reserved for a profile.
+     */
+    last_asn: string | null;
+    /**
+     * The IANA timezone the geo probe reported for the exit, for example
+     * `"America/Chicago"`, or `null` when it reported none.
+     *
+     * Written by the same check that writes `last_asn`, and cleared with it when
+     * the endpoint changes. It is not decoration: a profile on
+     * `geo_mode: "follow_exit"` adopts THIS zone at every start when the country's
+     * cohort knows it, instead of the country's canonical one, so a US proxy
+     * exiting in Tulsa leaves the profile on `America/Chicago` rather than
+     * `America/New_York`.
+     */
+    last_timezone: string | null;
+    last_check_at: number | null;
+    healthy: boolean | null;
+    /** Round-trip latency of the last health check, in ms. */
+    last_latency_ms: number | null;
+    /**
+     * The row holds credentials that could not be decrypted (a database restored
+     * without its master key). Every launch through it fails closed, so a screen
+     * that shows only `healthy` paints such a row green while nothing can use it.
+     * Omitted by the daemon when false.
+     */
+    credentials_unreadable?: boolean;
+    created_at: number;
+}
+/**
+ * Who depends on one proxy, as `GET /v1/proxies` reports it per row.
+ *
+ * `count` is exact, `names` holds at most three. A proxy shared by a fleet must
+ * not drag every profile name into the listing, so showing the names without the
+ * count would turn "three of forty" into "these three".
+ */
+interface ProxyUsage {
+    count: number;
+    names: string[];
+}
+/** A row of the proxy LIST: the proxy plus who uses it. The single GET has no `used_by`. */
+interface ProxyRow extends Proxy {
+    used_by: ProxyUsage;
+}
+
+/** Per-detector outcome; `skip` means the page could not be evaluated, NOT a pass. */
+type AuditVerdict = 'pass' | 'warn' | 'fail' | 'skip' | 'error';
+interface AuditDetectorReport {
+    id: string;
+    verdict: AuditVerdict;
+    detail: string;
+}
+interface AuditReport {
+    schema_version: number;
+    timestamp: string;
+    overall: AuditVerdict;
+    detectors: AuditDetectorReport[];
+}
+interface AuditStatus {
+    profile_id: string;
+    /** `idle` (never run since the daemon started), `running`, or `finished`. */
+    state: 'idle' | 'running' | 'finished';
+    started_at?: number;
+    finished_at?: number;
+    /** Why the RUN failed, distinct from a detector's own `skip`. */
+    error?: string;
+    report?: AuditReport;
+}
+/** How far a claim reaches. `machine` means this computer has no account key yet. */
+type ExitScope = 'machine' | 'account';
+/** One exit address a profile owns. */
+interface ExitClaim {
+    /** The comparison unit: the whole address for IPv4, the `/64` block for IPv6. */
+    addr: string;
+    /** `mobile` | `residential` | `datacenter` | `unknown`. Sets how long it is held. */
+    class: string;
+    scope: ExitScope;
+    first_seen: number;
+    last_seen: number;
+    expires_at: number;
+}
+/** A profile's exit-address situation. */
+interface ExitStatus {
+    /** Whether the rule applies to this installation at all. */
+    enabled: boolean;
+    /** Derived from the newest claim, not from configuration. */
+    scope: ExitScope;
+    /** The IPv4 address in use, when one is claimed. Carries its `v4:` prefix. */
+    current: string | null;
+    /**
+     * The IPv6 `/64` in use, when the daemon measures v6 (`[exit] probe_url_v6`)
+     * and the exit answered over it. `null` is the ordinary case and says nothing
+     * about the exit: without that setting the guard never asks.
+     */
+    current_v6: string | null;
+    /** How many addresses this profile owns. Both families count. */
+    owned: number;
+    claims: ExitClaim[];
+    /** Set when the profile has no proxy and is therefore exempt. */
+    note: string | null;
+}
+
+/**
+ * Wire types: a 1:1 mirror of the daemon's serialized domain model and of the
  * endpoint contract, and the one source of both on the TypeScript side.
  *
  * These files import nothing but each other, which keeps them usable inside a
@@ -429,12 +768,6 @@ declare const RUNTIME_STATES: readonly RuntimeState[];
 /** `GeoMode`. Default `follow_exit`. */
 type GeoMode = 'strict_expected' | 'follow_exit' | 'off';
 declare const GEO_MODES: readonly GeoMode[];
-/** `ProxyKind`. */
-type ProxyKind = 'http' | 'socks5' | 'gateway';
-declare const PROXY_KINDS: readonly ProxyKind[];
-/** `Rotation`. */
-type Rotation = 'sticky' | 'rotating';
-declare const ROTATIONS: readonly Rotation[];
 /** `SessionKind`. */
 type SessionKind = 'cookies' | 'local_storage' | 'indexed_db' | 'service_worker';
 type OsFamily = 'windows' | 'macos' | 'linux';
@@ -542,565 +875,1953 @@ interface Preset {
     config: PresetConfig;
     created_at: number;
 }
-/** What lies behind the page: a gradient, a colour, an image, or nothing. */
-type VideoBackground = {
-    kind: 'gradient';
-    colors: string[];
-} | {
-    kind: 'solid';
-    color: string;
-} | {
-    kind: 'image';
-    media_id: string;
-} | {
-    kind: 'none';
-};
-/** Intro and outro. `hold_result` holds the last frame instead of a card. */
-type VideoCard = {
-    style: 'title_card';
-    seconds: number;
-} | {
-    style: 'hold_result';
-    seconds: number;
-};
-/** Where the finished video goes. */
-type VideoDestination = {
-    kind: 'local';
-} | {
-    kind: 'link';
-    expires_days: number | null;
-    download: boolean;
-    passcode: boolean;
-};
-/** An additional output with its own dimensions. Objects, never bare strings. */
-interface ExtraOutput {
-    preset: ExportPresetName;
-    width?: number | null;
-    height?: number | null;
-    fps?: number | null;
-    colors?: number | null;
-    max_bytes?: number | null;
+/** `GET /v1/persona/constraints`: the values a preset may constrain to. */
+interface PersonaConstraintOptions {
+    countries: string[];
 }
-/** Background music, by media id, with its level. */
-interface MusicBed {
-    media_id: string;
-    gain_db: number;
+interface CreateGroupBody {
+    name: string;
+}
+type UpdateGroupBody = Partial<CreateGroupBody>;
+interface CreatePresetBody {
+    name: string;
+    constraints?: PresetConstraints;
+    config?: PresetConfig;
+}
+type UpdatePresetBody = Partial<CreatePresetBody>;
+interface SessionExportBody {
+    password: string;
+    kinds?: SessionKind[];
+}
+interface SessionExportResult {
+    bundle: string;
+    /**
+     * Whether the cookies came out of the RUNNING browser for this export.
+     *
+     * `false` means the bundle carries only what was stored earlier, which for a
+     * stopped profile is all there can be: a browser holds its jar in its own
+     * process. Export while the profile runs for a current session.
+     */
+    harvested?: boolean;
+    /** Why the bundle is thinner than it could be, when it is. */
+    note?: string;
+}
+interface SessionImportBody {
+    password: string;
+    bundle: string;
 }
 /**
- * The recipe of a video: everything about the FORM, nothing about the content.
+ * Trusted-input payload (`POST /v1/profiles/:id/input`). Only
+ * `action` and `humanize` are fixed by the API contract; the per-action
+ * coordinate fields below are the SDK's assumption about the daemon's input
+ * layer.
+ */
+type TrustedInputBody = {
+    action: 'move';
+    x: number;
+    y: number;
+    width?: number;
+    humanize?: boolean;
+} | {
+    action: 'click';
+    x: number;
+    y: number;
+    button?: string;
+    click_count?: number;
+    width?: number;
+    humanize?: boolean;
+} | {
+    action: 'type';
+    text: string;
+    humanize?: boolean;
+} | {
+    action: 'scroll';
+    x: number;
+    y: number;
+    delta_x?: number;
+    delta_y?: number;
+    humanize?: boolean;
+};
+/** Who is driving: an agent holding a lease, or a person at a window. */
+/** `workflow`: the session is one segment of a workflow run (`wf_run_id`). */
+type RunActor = 'agent' | 'human' | 'workflow';
+/** How a run ended. `reached`/`partial` appear only when a source claimed it. */
+type RunOutcome = 'running' | 'reached' | 'partial' | 'blocked' | 'interrupted' | 'unknown';
+/** What kind of thing a trail entry is. */
+type StepKind = 'page' | 'action' | 'interruption';
+/** The element a step acted on, as it can still be recognised later. */
+interface StepTarget {
+    role: string;
+    name: string;
+}
+/** One tool call, as the operator gets to read it back. */
+interface RunStep {
+    /** Position within the run, starting at 1. */
+    seq: number;
+    at: number;
+    duration_ms: number | null;
+    kind: StepKind;
+    /** The tool name; `null` for a synthetic `page` step. */
+    tool: string | null;
+    target: StepTarget | null;
+    /** A short human line. Carries typed text unless `redacted`. */
+    summary: string | null;
+    redacted: boolean;
+    /** Set on `page` steps. */
+    url: string | null;
+    /** Path of the still under the runs API; the image is fetched separately. */
+    shot_path: string | null;
+    /**
+     * What the call produced, in one line: "3 blocks, 122 characters",
+     * "no visible change · 14 elements".
+     *
+     * `summary` says what the agent asked for, this says what came back. A step
+     * recorded before this field existed has `null`.
+     */
+    result: string | null;
+    error: string | null;
+    /** The workflow step this call belongs to; absent outside a workflow run. */
+    wf_seq?: number | null;
+}
+/** What one running profile is showing. */
+interface ProfileActivity {
+    profile_id: string;
+    profile_name: string;
+    url: string;
+    title: string;
+    actor: RunActor;
+    /** Unix seconds this address was first seen. */
+    since: number;
+    /** The browser did not answer the last sweep; this is the last known value. */
+    stale: boolean;
+}
+
+/** What a stored value is. */
+type SecretKind = 'api_token' | 'password' | 'recovery_code' | 'totp_seed' | 'private_key' | 'unknown';
+/** How the layer came to know it. The first three are the honest origins. */
+type SecretOrigin = 'generated' | 'stored' | 'typed' | 'captured';
+/** How narrowly it is bound to where it may be used. */
+type SecretBindingMode = 'domain' | 'host' | 'prefix' | 'exact' | 'off';
+/** Where it stands between "just seen" and "known good". */
+type SecretState = 'quarantined' | 'confirmed' | 'doubtful' | 'released';
+interface SecretRow {
+    id: string;
+    /** The immutable name inside the placeholder. Renaming changes the title. */
+    label: string;
+    display_title?: string | null;
+    /** The placeholder for THIS daemon run. A new run draws a new session part. */
+    secret_ref?: string;
+    kind: SecretKind;
+    origin: SecretOrigin;
+    detected_by?: string | null;
+    binding_mode: SecretBindingMode;
+    binding_value?: string | null;
+    field_bound: boolean;
+    state: SecretState;
+    sole_copy: boolean;
+    /** Only present where the length is the FORMAT's rather than the value's. */
+    length?: number | null;
+    expires_at?: number | null;
+    created_at: number;
+    updated_at: number;
+    last_used_at?: number | null;
+    value_unreadable?: boolean;
+}
+interface SecretListResult {
+    secrets: SecretRow[];
+    /** Values still being censored that have no entry, because the list is full. */
+    withheld_without_an_entry: number;
+    layer_enabled: boolean;
+}
+/** What may be changed about one entry. The label is deliberately absent. */
+interface SecretPatchBody {
+    display_title?: string;
+    binding_mode?: SecretBindingMode;
+    binding_value?: string;
+    clear_binding_value?: boolean;
+    field_bound?: boolean;
+    state?: SecretState;
+    expires_at?: number;
+    clear_expires_at?: boolean;
+}
+interface SecretRunMention {
+    run_id: string;
+    goal: string;
+    started_at: number;
+    steps: number;
+}
+interface SecretDeleteResult {
+    deleted: string;
+    label: string;
+    /** The runs this entry appeared in, so nothing is removed blind. */
+    appeared_in_runs: SecretRunMention[];
+}
+interface SecretScrubResult {
+    text: string;
+    /** Which entries were replaced, by label. Never a value. */
+    replaced: string[];
+}
+interface SecretRunBody {
+    /** `NAME=<label>` pairs. At least one is required. */
+    env: string[];
+    /** The command and its arguments, already split. Never a shell line. */
+    command: string[];
+    cwd?: string;
+    timeout_secs?: number;
+}
+interface SecretRunResult {
+    command: string;
+    exit_code: number | null;
+    stdout: string;
+    stderr: string;
+    values_supplied: string[];
+}
+
+/**
+ * The per-profile task list and the profile's own durable memory.
  *
- * Steps, length, title and narration come from the request, never from here;
- * the only free text field is `ai_label.text`.
+ * One of the files that are the daemon's wire contract.
  */
-interface VideoPresetConfig {
-    output: {
-        aspect: '16:9' | '9:16' | '1:1';
-        resolution: '720p' | '1080p' | '4k';
-        fps: number;
-    };
-    frame: {
-        background: VideoBackground;
-        padding_pct: number;
-        corner_radius_px: number;
-        shadow: 'none' | 'soft' | 'hard';
-        inset_px: number;
-        window_chrome: 'none' | 'plain' | 'address_bar';
-    };
-    cursor: {
-        scale: number;
-        style: 'arrow_dark' | 'arrow_light' | 'dot' | 'touch';
-        click: 'ripple' | 'ring' | 'none';
-        /** `null` keeps the pointer visible forever. */
-        hide_after_ms: number | null;
-        loop: boolean;
-    };
-    camera: {
-        zoom: 'off' | 'gentle' | 'medium' | 'strong';
-        motion_blur: boolean;
-        tightening: 'none' | 'normal' | 'strong';
-        ride: 'calm' | 'standard' | 'brisk';
-        zoom_scope: 'canvas' | 'card';
-    };
-    audio: {
-        /** `"<provider>:<voice>"`, or `null` for a silent video. */
-        voice: string | null;
-        language: string;
-        subtitles: 'burned' | 'file' | 'off';
-        /** `custom:<media_id>` names an uploaded font (media kind `subtitle_style`). */
-        subtitle_style: 'classic' | 'word' | `custom:${string}`;
-        page_audio: boolean;
-        music: MusicBed | null;
-    };
-    cards: {
-        intro: VideoCard | null;
-        outro: VideoCard | null;
-    };
-    masking: {
-        level: 'off' | 'secrets' | 'secrets_and_ids';
-        style: 'bar' | 'pixelate' | 'blur' | 'placeholder';
-    };
-    export: {
-        preset: ExportPresetName;
-        also: ExtraOutput[];
-        destination: VideoDestination;
-    };
-    ai_label: {
-        enabled: boolean;
-        text: string;
-        position: 'top_left' | 'top_right' | 'bottom_left' | 'bottom_right';
-    };
+/**
+ * Where a task stands.
+ *
+ * Four words and no more. There is deliberately no `blocked` and no `partial`:
+ * `in_progress` already carries "somebody tried and did not finish", and why it
+ * failed belongs in the run trail, which is built to hold exactly that.
+ *
+ * `cancelled` is `done` with a different word. Both are endings, both fall out
+ * of the list a day later; the separate word is so a reader can tell "we did it"
+ * from "we called it off".
+ */
+type TaskState = 'open' | 'in_progress' | 'done' | 'cancelled';
+/** One task on one profile. */
+interface ProfileTask {
+    id: string;
+    profile_id: string;
+    /** Carried along so a fleet-wide list can say whose task a row is. */
+    profile_name: string;
+    /**
+     * The IANA zone `due_at` should be READ in: the profile's own.
+     *
+     * Without it a viewer reads their own clock and acts on the wrong number, and
+     * an account posting at three in the morning local time is exactly the
+     * behavioural tell this product avoids everywhere else. Derived at query time,
+     * never stored on the task: `geo_mode = follow_exit` rewrites the persona's
+     * zone at every launch.
+     */
+    profile_timezone: string | null;
+    /** One line saying what to do. A task names its material, it does not hold it. */
+    title: string;
+    state: TaskState;
+    /**
+     * Deadline in unix seconds (UTC), or `null` for work that is owed but not owed
+     * at any particular moment.
+     *
+     * Read it in the PROFILE's timezone, not the viewer's: a task due at nine means
+     * nine where the identity lives, and an account that posts at three in the
+     * morning local time is a behavioural tell.
+     *
+     * It is a deadline, not a trigger. Nothing runs by itself.
+     */
+    due_at: number | null;
+    created_at: number;
+    /** When the current claim was taken; cleared when the task leaves `in_progress`. */
+    claimed_at: number | null;
+    finished_at: number | null;
+    /**
+     * Set when a claim nobody finished was handed back after six hours.
+     *
+     * Whoever picks such a task up has to check whether the work already happened:
+     * the previous run may have published the post and died before it could say so.
+     */
+    last_attempt_at: number | null;
+}
+/** Filters for listing tasks. All are narrowings; absent means unconstrained. */
+interface ListTasksParams {
+    profile_id?: string;
+    state?: TaskState;
+    /** Only tasks whose deadline is at or before this unix second. */
+    due_before?: number;
+    /** Substring of the title, case-insensitive. */
+    q?: string;
+    limit?: number;
+    offset?: number;
+}
+/** Add the same task to one or many profiles, one row each. */
+interface CreateTasksBody {
+    profile_ids: string[];
+    title: string;
+    due_at?: number | null;
+}
+/** What one create call did. */
+interface CreateTasksResult {
+    created: ProfileTask[];
+    /**
+     * Profiles that no longer exist. Named rather than dropped: adding a task to
+     * twenty profiles of which three were deleted writes seventeen rows and says
+     * which three it could not.
+     */
+    missing: string[];
+}
+/** The one transition this surface performs. */
+interface PatchTaskBody {
+    /** Only `cancelled`, and only on a task nobody has claimed. */
+    state: 'cancelled';
+}
+/**
+ * A profile's durable memory: the `PROFILE.md` at the top of its directory.
+ *
+ * Same purpose as a repository's `CLAUDE.md`. What goes in it is the customer's
+ * business; nothing writes a scaffold or seeds a value, and a profile starts with
+ * no file rather than an empty one.
+ */
+interface ProfileMemory {
+    /** `null` while nobody has written one. */
+    content: string | null;
+    /** The absolute path, so a person can open it in their own editor. */
+    path: string;
+    updated_at: number | null;
+    /** The ceiling a write is measured against, in bytes. */
+    max_bytes: number;
+}
+/** Replace a profile's memory. The text is stored verbatim. */
+interface WriteMemoryBody {
+    content: string;
+}
+
+type ColumnType = 'text' | 'number' | 'bool' | 'date' | 'file' | 'json' | 'status' | (string & {});
+type ColumnKind = 'data' | 'status' | (string & {});
+/** One column. A cell names it by id; renaming keeps every reference. */
+interface Column {
+    id: string;
+    name: string;
+    type: ColumnType;
+    kind: ColumnKind;
+    /** The workflow a status column belongs to. */
+    owner_workflow?: string | null;
+    position: number;
+}
+/** What deletes rows by itself; every rule sends to the bin for 30 days. */
+type Retention = {
+    mode: 'keep';
+} | {
+    mode: 'older_than';
+    days: number;
+} | {
+    mode: 'date_column';
+    col: string;
+    days: number;
+} | {
+    mode: 'on_run_start';
+    workflow_id: string;
+};
+/** A table as a list shows it. */
+interface TableMeta {
+    id: string;
+    name: string;
+    description?: string | null;
+    backing: 'local' | 'sheet' | (string & {});
+    columns: Column[];
+    /** Rows outside the bin and outside a running import. */
+    row_count: number;
+    used_by: {
+        workflow_id: string;
+        via: 'draft' | 'published' | (string & {});
+    }[];
+    retention: Retention;
+    /**
+     * A linked sheet: the writer's state, the changes still queued, and those
+     * Google refused outright (`failed`) with Google's own reason for the latest.
+     */
+    sheet?: {
+        state: string;
+        next_send_at?: number | null;
+        queued: number;
+        failed?: number;
+        failure?: string | null;
+    } | null;
+    import?: {
+        id: string;
+        state: string;
+        rows_total: number;
+        rows_done: number;
+    } | null;
+    updated_at: number;
+    deleted_at?: number | null;
+}
+/**
+ * Before deleting a workflow: the tables only it uses, and those another
+ * workflow uses too, each with every workflow that uses it.
+ */
+interface DeletePreview {
+    only_used_here: TableMeta[];
+    shared: TableMeta[];
+}
+/** A cell: a plain value, a status cell, or `{ withheld }` for a marked one. */
+type CellValue = string | number | boolean | null | Record<string, unknown>;
+/** One row with its cells by column id. */
+interface Row {
+    rid: string;
+    cells: Record<string, CellValue>;
+    position: number;
+    created_at: number;
+    updated_at: number;
+    claimed_by_run?: string | null;
+}
+interface CreateTableBody {
+    name: string;
+    description?: string;
+    columns?: {
+        name: string;
+        type?: ColumnType;
+    }[];
+}
+interface UpdateTableBody {
+    name?: string;
+    description?: string;
+    retention?: Retention;
+}
+interface ListRowsParams {
+    page?: number;
+    /** 1 to 500, default 50. */
+    page_size?: number;
+    /** A column by id or name: the rows in its order (a number column by value). */
+    sort?: string;
+    /** `asc` (the default) or `desc`. */
+    order?: 'asc' | 'desc';
+    /**
+     * Conditions every row meets, as `data_get` takes them; the client sends
+     * them as JSON. `total` then counts the rows that match.
+     */
+    where?: Array<{
+        col: string;
+        op: 'eq' | 'empty' | 'not_empty' | 'contains' | 'status_not' | (string & {});
+        value?: unknown;
+    }>;
+}
+interface RowsPage {
+    rows: Row[];
+    page: number;
+    page_size: number;
+    total: number;
 }
 /**
- * A video RECIPE: how a recording becomes a video (`/v1/video-presets`).
- *
- * `config` was an open object for a long time, on the argument that a second
- * TypeScript copy of a two-dozen-enum schema is a second place for it to rot.
- * The copy exists now because a form over an open object is a pile of casts and
- * a typo in it only surfaces as a 400 after somebody pressed save; what took
- * the argument's teeth is that the copy is held against the Rust source field
- * by field (`preset-schema-mirror`), so it cannot rot quietly.
+ * One change of a table. A cell names its column by id or by name; every op
+ * is checked against the table as it stands after the ops before it.
  */
-interface VideoPreset {
-    id: string;
+type TableOp = {
+    op: 'add_column';
     name: string;
-    /** Shipped with the product; can be duplicated but not edited or deleted. */
-    builtin: boolean;
-    config: VideoPresetConfig;
+    type?: ColumnType;
+} | {
+    op: 'rename_column';
+    col: string;
+    name: string;
+} | {
+    op: 'remove_column';
+    col: string;
+} | {
+    op: 'add_rows';
+    rows: Record<string, CellValue>[];
+} | {
+    op: 'update_cells';
+    rid: string;
+    cells: Record<string, CellValue>;
+} | {
+    op: 'delete_rows';
+    rids: string[];
+} | {
+    op: 'restore';
+    rids: string[];
+} | {
+    op: 'set_retention';
+    retention: Retention;
+} | {
+    op: 'delete_table';
+};
+interface EditTableBody {
+    ops: TableOp[];
+}
+/** One result per op, in order: `{ rids }` for `add_rows`, `{ col_id }` for a column op. */
+interface EditTableResult {
+    results: Record<string, unknown>[];
+}
+/** What an import does with the rows already there. */
+type ImportMode = 'append' | 'replace';
+interface ImportTableParams {
+    /** `replace` sends the rows already there to the bin once the import is complete. */
+    mode?: ImportMode;
+    /** The sheet of a spreadsheet to read; the first one otherwise. */
+    sheet?: string;
+}
+/** What an import did. */
+interface ImportResult {
+    import_id: string;
+    /** The rows it brought. */
+    rows: number;
+    /** Columns the file named that the table did not have. */
+    columns_added: string[];
+    /** Status columns the file named: only a run writes those. */
+    columns_skipped: string[];
+    /** Rows `replace` sent to the bin. */
+    replaced: number;
+}
+/** The two formats a table goes out in. */
+type ExportFormat = 'csv' | 'xlsx';
+/**
+ * A Google account connected for linked sheets (workflows SPEC A2 §5.2): our
+ * Google project by default (`ours`), or your own (`own`). Never a token.
+ */
+interface GoogleConnection {
+    id: string;
+    google_email: string;
+    client_kind: 'ours' | 'own' | (string & {});
+    /** Short names: `drive.file`, later also `spreadsheets`. */
+    scopes: string[];
     created_at: number;
-    updated_at: number;
+    last_used_at?: number | null;
+    revoked_at?: number | null;
 }
-/** One named frame of the sample film the preview can jump to, with the clip window around it. */
-interface PreviewMoment {
-    key: string;
-    label: string;
-    frame: number;
-    from: number;
-    to: number;
+/** Connect through our Google project (`{}`) or your own project's desktop client. */
+interface ConnectGoogleBody {
+    client?: 'ours' | 'own';
+    client_id?: string;
+    client_secret?: string;
 }
-/** A preset field the sample film cannot show, and why. */
-interface PreviewHidden {
-    field: string;
-    why: string;
+/** Link a table to a sheet: a new table by name, or an existing one. */
+interface LinkSheetBody {
+    table_name?: string;
+    table_id?: string;
+    /** A pasted sheet address; needs Google's `spreadsheets` permission. */
+    spreadsheet_url?: string;
 }
-/** `POST /v1/video-presets/preview`: one still of the sample film under an unsaved config. */
-interface VideoPresetPreviewBody {
-    config: VideoPresetConfig;
-    frame?: number;
-    moment?: string;
-    name?: string;
-    /** Draw at this short side instead of the recipe's own, 360 to 2160. */
-    proxy_short_side?: number;
+
+type UnknownEffectPolicy = 'park' | 'halt' | 'retry';
+interface StartWorkflowRunBody {
+    inputs?: Record<string, unknown>;
+    profile_id?: string;
+    /** `published` (the default), `draft` for a test run of the draft, or a version number. */
+    version?: 'published' | 'draft' | number;
+    /** Seconds the run may wait for a free profile or slot; default 3600. Not with `manual`. */
+    queue_timeout_s?: number;
+    /** What a step whose effect is unknown after a crash does. `retry` sends it again. */
+    on_unknown_effect?: UnknownEffectPolicy;
+    /** The trigger to start at, for a workflow with several. */
+    trigger_node?: NodeId;
+    /**
+     * The machine to run on: a `binding` of `workflowMachines()`, or the name of
+     * one machine. Default: the profile's home machine. The profile moves to the
+     * machine named here with its run.
+     */
+    run_on?: string;
+    /**
+     * A start by a person, as the app's "Run" sends it: the run is a hand start
+     * (`trigger: 'manual'`), goes ahead of automatic starts in the queue and
+     * waits there without a term. A script leaves it out and waits
+     * `queue_timeout_s`.
+     */
+    manual?: boolean;
 }
-/** The reply: the picture as a data URL plus what the film looks like under this config. */
-interface VideoPresetPreview {
-    width: number;
-    height: number;
-    fps: number;
-    frames: number;
-    frame: number;
-    moments: PreviewMoment[];
-    hidden: PreviewHidden[];
-    notes: string[];
-    image: string;
+interface StartWorkflowRunParams {
+    /** Seconds to hold the request for the end of the run, up to 110. */
+    wait?: number;
 }
-/** `POST /v1/video-presets/preview/clip`: frames `from_frame..to_frame` of the sample film as an MP4. */
-interface VideoPresetClipBody {
-    config: VideoPresetConfig;
-    /** Absent means the start of the film. */
-    from_frame?: number;
-    /** Exclusive; absent means the end of the film. */
-    to_frame?: number;
-    name?: string;
-    /** Draw at this short side instead of the recipe's own, 360 to 2160. */
-    proxy_short_side?: number;
+/** What a start answers. `result` arrives with a run that succeeded within `wait`. */
+interface RunStartResult {
+    run_id: string;
+    status: WorkflowRunStatus;
+    generation_id: string;
+    /**
+     * Set when the start went to the machine its profile lives on: no run
+     * starts here, `run_id` is empty, and this key names the forwarded start.
+     */
+    forward_ref?: string;
+    result?: Record<string, unknown>;
+    /**
+     * The marked parts of `result` as JSON Pointers, such as `["/key"]` for the
+     * value of a secret variable. The result is whole on this route; an agent
+     * reads these parts as `"[withheld]"`.
+     */
+    tainted_paths?: string[];
+    error?: string;
 }
-/** One progress frame of the clip's SSE stream (`event: progress`). */
-interface VideoPresetClipProgress {
-    done: number;
+/**
+ * Why a part of a value is marked: a vault value, a secret (a secret variable,
+ * a mail's code or links, labelled with where it came from) or a value
+ * recognised as secret.
+ */
+type ValueMark = 'vault' | {
+    secret: {
+        label: string;
+    };
+} | {
+    recognized: {
+        kind: string;
+    };
+};
+type WorkflowRunKind = 'production' | 'test' | 'fork' | 'probe' | (string & {});
+type WorkflowTriggerKind = 'manual' | 'schedule' | 'webhook' | 'agent_call' | 'mcp' | 'rest' | 'workflow' | 'email' | 'table_row' | 'page_change' | 'fleet' | (string & {});
+type WorkflowRunStatus = 'queued' | 'starting' | 'running' | 'waiting' | 'awaiting_approval' | 'awaiting_connection' | 'repairing' | 'halted' | 'succeeded' | 'failed' | 'cancelled' | 'expired' | (string & {});
+/** Why a run ended or stands where it stands; a newer daemon's reason reads as `other`. */
+type WorkflowStatusReason = string;
+/** Why a run is not running right now: a code and its details. */
+interface WaitReason {
+    code: string;
+    [key: string]: unknown;
+}
+/** The whole row of a run. */
+interface WorkflowRun {
+    id: string;
+    workflow_id: string;
+    workflow_name: string;
+    version_id: string;
+    version_number: number | null;
+    kind: WorkflowRunKind;
+    trigger: WorkflowTriggerKind;
+    trigger_node: NodeId | null;
+    parent_run_id: string | null;
+    /** One trigger across all its profiles and machines. */
+    generation_id: string;
+    lineage_id: string;
+    call_depth: number;
+    target_profile_id: string | null;
+    machine_id: string;
+    forwarded_from: string | null;
+    status: WorkflowRunStatus;
+    wait_reason: WaitReason | null;
+    status_reason: WorkflowStatusReason | null;
+    priority: number;
+    enqueued_at: number;
+    not_before: number | null;
+    expires_at: number | null;
+    started_at: number | null;
+    finished_at: number | null;
+    headless: boolean;
+    current_node: NodeId | null;
+    current_iter: string | null;
+    steps_done: number;
+    review_items: number;
+    usage_in: number;
+    usage_out: number;
+    /** Millionths of a US dollar. */
+    cost_micros: number;
+    /** One sentence from a fixed template, never page text. */
+    error: string | null;
+    unreadable: boolean;
+}
+interface ListWorkflowRunsParams {
+    workflow_id?: string;
+    profile_id?: string;
+    status?: WorkflowRunStatus;
+    /** Only runs that have not ended. */
+    active?: boolean;
+    kind?: WorkflowRunKind;
+    generation_id?: string;
+    /** 1 to 500, default 50. */
+    limit?: number;
+    /** The page after this run id: the last one of the previous page. */
+    after?: string;
+}
+type StepStatus = 'started' | 'succeeded' | 'failed' | 'skipped' | 'unknown' | 'parked' | 'memo' | 'interrupted' | (string & {});
+interface ShotRef {
+    agent_run_id: string;
+    agent_seq: number;
+}
+interface NodeRunState {
+    status: StepStatus;
+    attempts: number;
+    duration_ms: number | null;
+    error_code: string | null;
+    last_seq: number;
+    /** The newest still the run trail took for this step; fetch it with `getRunShot`. */
+    shot: ShotRef | null;
+}
+interface LoopSummary {
+    loop_node: NodeId;
+    parent_iter: string;
     total: number;
+    done: number;
+    review: number;
+    failed: number;
+    pending: number;
+}
+/** One run with the state of every node, for one loop item or the latest. */
+/** One row to check: the effect's row path (`n_2=<item key>`) and the node that ran it. */
+interface ReviewItem {
+    row_key: string;
+    node_id: NodeId;
+}
+interface RunView {
+    run: WorkflowRun;
+    iter: string | null;
+    nodes: Record<NodeId, NodeRunState>;
+    loops: LoopSummary[];
+    /** The rows to check: effects that may have landed, each awaiting a decision. */
+    review: ReviewItem[];
+}
+interface GetWorkflowRunParams {
+    /** The loop item to show, such as `n_7:231`. */
+    iter?: string;
+}
+/** A folder file blocks may use on this machine while "only granted folders" is on. */
+interface GrantedFolder {
+    path: string;
+    /** `read` grants reading only; `write` reading and writing. */
+    mode: 'read' | 'write';
+    added_at: number;
+    added_via: string;
+}
+/** This machine's folder boundary for file blocks (H10, H11): a person's switch and list. */
+interface WorkflowFileAccess {
+    only_granted_folders: boolean;
+    folders: GrantedFolder[];
 }
 /**
- * `event: started`, the FIRST frame of the SSE answer: the id under which the
- * bytes can already be followed (`?follow=1`), and the shape of the film.
- *
- * It exists so a player can begin while the render still runs. Without it the
- * id arrives with `done`, and by then there is nothing left to follow.
+ * One registrable domain on the fast mode's list, an account setting of the operator.
+ * A domain switches itself off when bot protection shows on it; `putWorkflowFastDomain`
+ * switches it on again.
  */
-interface VideoPresetClipStarted {
-    id: string;
-    frames: number;
-    fps: number;
-    width: number;
-    height: number;
+interface FastDomain {
+    domain: string;
+    added_at: number;
+    disabled_at: number | null;
+    /** The account state that switched it off, such as `captcha`. */
+    disabled_reason: string | null;
+    /** The profile the protection showed on. */
+    disabled_profile: string | null;
+}
+/** The fast mode's domain list, empty by default. */
+interface FastDomains {
+    domains: FastDomain[];
+}
+/** The ways an approval can be answered. */
+type ApprovalWay = 'desktop' | 'portal' | 'mail' | 'push' | 'webhook' | 'agent_mcp' | 'agency';
+/**
+ * The account's approval webhook: where an approval that names the way `webhook`
+ * is announced, signed with a `secret` variable of the approval's workflow. It is
+ * one setting for every machine of the account.
+ */
+interface ApprovalWebhook {
+    /** An `http` or `https` address; `null`: none, and on `PUT` clears it. */
+    url: string | null;
+    /** The name of the `secret` variable that signs; `null`: unsigned. */
+    secret_ref: string | null;
 }
-/** The finished clip (`event: done`, or the blocking JSON reply); the bytes come from `GET /v1/video-presets/preview/clip/:id`. */
-interface VideoPresetClip {
+/**
+ * One approval of this machine: "Ask for Approval", a target question, a repair or an agent
+ * step waiting for a person. `detail` (the question with its values) stays on this machine.
+ */
+interface Approval {
     id: string;
-    from_frame: number;
-    to_frame: number;
-    fps: number;
-    width: number;
-    height: number;
-    frames: number;
-    seconds: number;
-    bytes: number;
-    encoder: string;
-    cached: boolean;
-    audio: boolean;
+    /** The running number on this machine, for display ("A-77"). */
+    seq: number;
+    run_id: string;
+    workflow_id: string;
+    node_id: string;
+    iter_key: string;
+    kind: 'ask_for_approval' | 'repair_fix' | 'agent_irreversible' | 'target_confirm' | (string & {});
+    risk: 'read' | 'reversible' | 'irreversible';
+    summary: string;
+    detail: Record<string, unknown> | null;
+    ways: ApprovalWay[];
+    state: 'pending' | 'approved' | 'rejected' | 'expired' | 'cancelled';
+    /** The browser stays open until then (unix seconds). */
+    hold_until: number;
+    /** Without an answer by then the approval expires. */
+    expires_at: number;
+    on_timeout: 'abort' | 'skip' | null;
+    grant_key: string | null;
+    decided_via: ApprovalWay | null;
+    decided_actor: 'owner' | 'agency' | 'agent' | null;
+    decided_by: string | null;
+    decided_at: number | null;
+    decision_detail: Record<string, unknown> | null;
+    consumed_at: number | null;
+    created_at: number;
 }
-/** `GET /v1/persona/constraints`: the values a preset may constrain to. */
-interface PersonaConstraintOptions {
-    countries: string[];
+/** A decision from the app: approve or reject, with an optional note. */
+interface DecideApprovalBody {
+    verdict: 'approve' | 'reject';
+    /** The name shown with the decision. */
+    by?: string;
+    note?: string;
+    /** For a target question: the chosen candidate. */
+    detail?: Record<string, unknown>;
 }
-/** Proxy; credentials are write-only (`#[serde(skip_serializing)]`) and never returned. */
-interface Proxy {
+/**
+ * One file a run keeps, such as a screenshot or a PDF, without its bytes.
+ * A step hands out the same `{ id, name, mime, size }` as its `file` output.
+ */
+interface WorkflowRunFile {
     id: string;
-    kind: ProxyKind;
-    host: string;
-    port: number;
-    rotation: Rotation;
+    node_id: string;
+    iter_key: string;
+    name: string;
+    mime: string;
+    size: number;
+    created_at: number;
+}
+/** One step of a run, with what went in and what came out. */
+interface WorkflowStep {
+    run_id: string;
+    seq: number;
+    node_id: NodeId;
+    iter_key: string;
+    attempt: number;
+    status: StepStatus;
+    effect_class: 'pure' | 'read' | 'idempotent' | 'effect' | (string & {});
+    port: string | null;
+    profile_id: string | null;
+    agent_run_id: string | null;
+    version_id: string | null;
+    started_at: number;
+    finished_at: number | null;
+    duration_ms: number | null;
+    input: unknown;
+    output: unknown;
+    input_file: string | null;
+    output_file: string | null;
+    error_code: string | null;
+    account_state: string | null;
     /**
-     * The operator's own name for this row, or `null` if they never gave one.
-     *
-     * The only field that tells two rows of one provider pool apart: kind, host,
-     * port and rotation are identical across a bought gateway, and the session tag
-     * that actually differs sits in the write-only username. Do not fall back to
-     * `last_exit_ip` for identity; the health check wrote it hours or days ago and
-     * a rotating exit no longer has that address.
+     * The run's fixed sentence, then the tool's own reason ("#3 Open Link failed:
+     * loopback addresses ..."). Only this machine keeps it; the run's `error`
+     * carries the sentence alone.
      */
-    label: string | null;
-    last_exit_ip: string | null;
-    last_country: string | null;
+    error: string | null;
     /**
-     * The operator string the geo probe answered with, for example
-     * `"AS21928 T-Mobile USA, Inc."`. Part of the same measurement as the fields
-     * around it: one check writes them, an endpoint change clears them together.
-     * The daemon derives the address kind from it, which decides how long an
-     * address stays reserved for a profile.
+     * Notes without an error, such as `retention_skipped_busy`: the start cleared
+     * no table because another run was walking it.
      */
-    last_asn: string | null;
+    notes: string[];
     /**
-     * The IANA timezone the geo probe reported for the exit, for example
-     * `"America/Chicago"`, or `null` when it reported none.
-     *
-     * Written by the same check that writes `last_asn`, and cleared with it when
-     * the endpoint changes. It is not decoration: a profile on
-     * `geo_mode: "follow_exit"` adopts THIS zone at every start when the country's
-     * cohort knows it, instead of the country's canonical one, so a US proxy
-     * exiting in Tulsa leaves the profile on `America/Chicago` rather than
-     * `America/New_York`.
+     * The marked parts of `output` by JSON Pointer. The step routes show each
+     * one masked (`{"withheld": "secret", "label": "#1.code"}`).
      */
-    last_timezone: string | null;
-    last_check_at: number | null;
-    healthy: boolean | null;
-    /** Round-trip latency of the last health check, in ms. */
-    last_latency_ms: number | null;
+    output_marks?: Record<string, ValueMark>;
+}
+interface ListWorkflowRunStepsParams {
+    node?: NodeId;
+    iter?: string;
+    /** Only steps after this `seq`, for reading as the run goes. */
+    after?: number;
+}
+/** One switch: the account, a profile or a workflow. A switch without a row is on. */
+interface WorkflowSwitch {
+    /** `account`, `profile:<id>` or `workflow:<id>`. */
+    scope: string;
+    on: boolean;
+    changed_at: number;
+    changed_by: 'app' | 'phone' | 'mcp' | 'rest' | 'emergency_stop' | 'sync' | (string & {});
+    reason: string | null;
+}
+interface SetWorkflowSwitchBody {
+    /** `account`, `profile:<id>` or `workflow:<id>`. */
+    scope: string;
+    on: boolean;
+    reason?: string;
+}
+/** What the emergency stop did. */
+interface EmergencyStopResult {
+    /** Begun runs it ended. */
+    cancelled: number;
+    /** The account switch, now off. */
+    switch: WorkflowSwitch;
+}
+interface DecideWorkflowRunBody {
     /**
-     * The row holds credentials that could not be decrypted (a database restored
-     * without its master key). Every launch through it fails closed, so a screen
-     * that shows only `healthy` paints such a row green while nothing can use it.
-     * Omitted by the daemon when false.
+     * For a halted run: `done` (it worked), `retry` (send once more) or `abort`.
+     * For one row to check (with `row_key`): `done`, `retry` or `ignore`. On a
+     * run that has ended, `retry` starts a fork of it for that row alone (its
+     * `kind` is `fork`, its generation the run's), which waits 3600 s in the
+     * queue; on a run still under way the next run takes the row again.
      */
-    credentials_unreadable?: boolean;
+    decision: 'done' | 'retry' | 'abort' | 'ignore';
+    /** A row to check of the run, as `RunView.review` names it. */
+    row_key?: string;
+}
+/** "Run from step X" of a run (or a test run from here with `kind: 'test'`). */
+interface ForkWorkflowRunBody {
+    /** The node to go on from, such as `n_14`. */
+    from_node: NodeId;
+    /** End the run after this node ("until here"). */
+    to_node?: NodeId;
+    /** `fork` (default) or `test`. */
+    kind?: 'fork' | 'test';
+    /** Default: `published` for a fork, `draft` for a test run. */
+    version?: 'published' | 'source' | 'draft';
+    /**
+     * A start by a person, as the app's "Run from here" sends it: the fork
+     * waits in the queue without a term instead of 3600 s. The preview ignores it.
+     */
+    manual?: boolean;
+}
+/** What a fork would do, before it starts. */
+interface ForkPreview {
+    /** The source never reached the node: the run starts at the trigger. */
+    from_trigger: boolean;
+    /** Nodes whose outputs come from the source, in the order they ran. */
+    seeded: NodeId[];
+    /** Seeded nodes whose settings differ in the chosen version. */
+    stale: NodeId[];
+    will_run: NodeId[];
+    /** Nodes ahead that act outside (a message, a request). */
+    effects_ahead: NodeId[];
+    /** The trail step whose page the fork opens first. */
+    restore_from: {
+        agent_run_id: string;
+        seq: number;
+    } | null;
+}
+
+/** One run of the queue: a queued run's place in the dispatch order, `null` for a waiting one. */
+interface QueueEntry {
+    position: number | null;
+    run: WorkflowRun;
+}
+/** Where a forwarded start stands. A value a newer daemon adds reads as a plain string. */
+type ForwardState = 'pending' | 'sent' | 'succeeded' | 'failed' | 'cancelled' | 'expired' | 'rejected' | (string & {});
+/** A start that went to the machine its profile lives on, as this machine keeps it. */
+interface WorkflowForward {
+    /** The start's key; `forward_ref` in a start's answer. */
+    trigger_key: string;
+    workflow_id: string;
+    workflow_name: string;
+    generation_id: string;
+    profile_id: string | null;
+    /** The name of the machine the start went to. */
+    target_label: string | null;
+    /** `pending`: not yet at the control plane. `sent`: there, waiting for the home machine. */
+    state: ForwardState;
+    /** Whether the home machine answered when the start reached the control plane; `null` while unknown. */
+    home_online: boolean | null;
+    /** Unix seconds; `null` for a start by hand, which waits until it starts or is cancelled. */
+    expires_at: number | null;
+    error: string | null;
     created_at: number;
+    updated_at: number;
 }
 /**
- * Who depends on one proxy, as `GET /v1/proxies` reports it per row.
- *
- * `count` is exact, `names` holds at most three. A proxy shared by a fleet must
- * not drag every profile name into the listing, so showing the names without the
- * count would turn "three of forty" into "these three".
+ * The runs that wait: queued ones in dispatch order, then waiting ones by when
+ * they wake; and the starts that wait for the machine their profile lives on,
+ * oldest first.
  */
-interface ProxyUsage {
-    count: number;
-    names: string[];
+interface WorkflowQueue {
+    runs: QueueEntry[];
+    forwards: WorkflowForward[];
+}
+/** One group of this machine's ended runs (a test run never counts). */
+interface UsageRow {
+    /** The workflow id, the profile id or the day (`YYYY-MM-DD`), by `group_by`. */
+    key: string;
+    runs: number;
+    succeeded: number;
+    failed: number;
+    cancelled: number;
+    expired: number;
+    review_items: number;
+    /** `succeeded / (succeeded + failed)`; `null` without either. */
+    success_rate: number | null;
+    duration_ms_avg: number | null;
+    usage_in: number;
+    usage_out: number;
+    /** Millionths of a US dollar. */
+    cost_micros: number;
+}
+interface WorkflowUsageParams {
+    group_by: 'workflow' | 'profile' | 'day';
+    workflow_id?: string;
+    profile_id?: string;
+    /** First day, `YYYY-MM-DD`. */
+    from?: string;
+    /** Last day, `YYYY-MM-DD`. */
+    to?: string;
+}
+/** Where a planned start stands. A value a newer daemon adds reads as a plain string. */
+type WorkflowFireState = 'planned' | 'enqueued'
+/** A "Page Changed" look that started nothing; `state_reason` says why. */
+ | 'checked' | 'skipped_missed' | 'skipped_paused' | 'skipped_elsewhere' | 'superseded' | 'cancelled' | (string & {});
+/** One planned start of a "Schedule Window" trigger, planned 48 hours ahead in the zone the start uses. */
+interface WorkflowFire {
+    /** Also the run's `trigger_key`. */
+    id: string;
+    workflow_id: string;
+    version_id: string;
+    trigger_node: string;
+    profile_id: string | null;
+    /** `YYYY-MM-DD` in `tz`. */
+    local_date: string;
+    occurrence: number;
+    /** The zone, as the persona names it. */
+    tz: string;
+    fire_at: number;
+    /** Catching up ends here, and so does the queued run. */
+    latest_at: number;
+    window_end: number;
+    wake: boolean;
+    sleep_after: boolean;
+    state: WorkflowFireState;
+    /**
+     * Why it was skipped or withdrawn: `switch_off:<scope>`, `too_late`,
+     * `catch_up_off`, `newer_caught_up`, `expired_in_queue`, `zone_changed`,
+     * `replanned`, `no_schedule`, `profile_gone`, `trigger_gone`, `start_failed: ...`.
+     */
+    state_reason: string | null;
+    run_id: string | null;
+    updated_at: number;
+}
+/** Filters of the planned starts; `from` inclusive, `to` exclusive, Unix seconds. */
+interface WorkflowFiresParams {
+    workflow_id?: string;
+    profile_id?: string;
+    state?: WorkflowFireState;
+    from?: number;
+    to?: number;
+    /** 1 to 1000, default 200. */
+    limit?: number;
+}
+/** What one readiness item says. A value a newer daemon adds reads as a plain string. */
+type ReadinessStatus = 'pass' | 'warn' | 'fail' | 'unknown' | 'unsupported' | (string & {});
+/** A fix the app's readiness card can run; a fixed list, no free arguments. */
+type ReadinessFixKey = 'rtc_wake' | 'wake_task' | 'autostart' | 'autologon_on' | 'autologon_off' | (string & {});
+/** One thing this machine needs for a planned start that wakes it, with its reason and its fix. */
+interface ReadinessItem {
+    id: 'sleep_model' | 'rtc_wake_ac' | 'rtc_wake_dc' | 'power_source' | 'wake_task' | 'autostart' | 'autologon_after_restart' | 'hello_required' | 'password_on_wake' | 'clock_skew' | 'sync_key' | (string & {});
+    status: ReadinessStatus;
+    /** Stable code such as `modern_standby`; the app's text is keyed by it. */
+    reason_code: string;
+    /** English fallback text. */
+    reason: string;
+    /** The fix the app's card offers, run at the machine. */
+    fix: ReadinessFixKey | null;
+    /** Windows asks for an administrator's confirmation when the fix runs. */
+    needs_admin: boolean;
+}
+/** What this machine can do for a planned start, item by item. A host without wake support lists nothing. */
+interface WorkflowReadiness {
+    items: ReadinessItem[];
+}
+
+/** One published workflow with a "Webhook" trigger and its address. */
+interface WorkflowHook {
+    workflow_id: string;
+    workflow_name: string;
+    /** Paste this into the sending service; `null` until this machine is connected to the account's relay. */
+    address: string | null;
+    /** Calls the relay holds for the workflow's machine; `null` while this machine is off the relay. */
+    pending: number | null;
+    /** Calls that expired unfetched since this address was made. */
+    expired: number;
+    /** Unix seconds when this address was made. */
+    created_at: number;
+}
+interface WorkflowHookList {
+    hooks: WorkflowHook[];
+}
+/**
+ * A change this machine could not send to its other machines: larger than the
+ * sync carries, even split into parts (about 8 MB). Listed until a later
+ * version of the same workflow left this machine, or the workflow was deleted.
+ */
+interface UnsentChange {
+    /** `version`: a saved version of the workflow. `variables`: a value of its variables. */
+    subject: 'version' | 'variables' | 'other';
+    workflow_id: string | null;
+    /** The workflow's name on this machine now; `null` without one. */
+    workflow_name: string | null;
+    /** Its size, encrypted, in bytes. */
+    bytes: number;
+    /** When this machine first could not send it, unix seconds. */
+    since: number;
+}
+/**
+ * The workflow space at this machine (`GET /v1/workflow-sync`, and the
+ * `workflow_sync_changed` event). The route is read by the app's settings page;
+ * a script reads the same view from the event.
+ */
+interface WorkflowSyncView {
+    kind: 'own' | 'wl_client';
+    /** The sync key is not on this machine: edits and starts wait. */
+    locked: boolean;
+    /** This machine's clock is close enough to the account's for its changes to count. */
+    clock_ok: boolean;
+    /** The account's clock minus this machine's, in milliseconds; `null` before this machine reached its space. */
+    clock_offset_ms: number | null;
+    connected: boolean;
+    /**
+     * `false` while the control plane refuses this account: it has no workflow
+     * sync. Absent from a daemon up to 0.25.1, which means available.
+     */
+    available?: boolean;
+    server_claims: boolean;
+    /** Changes waiting for the clock. */
+    held_journal: number;
+    /** Changes not sealed yet, and sealed batches the account has not confirmed. */
+    backlog: {
+        changes: number;
+        batches: number;
+    };
+    brief_mode: 'readable' | 'e2e';
+    /** `agency` in the white-label app: the agency switches. */
+    brief_mode_by: 'owner' | 'agency';
+    phone_epoch: number;
+    /**
+     * What this machine could not send, oldest first; empty when every change
+     * left. Absent from a daemon up to 0.24.0.
+     */
+    unsent?: UnsentChange[];
+}
+/**
+ * The edit right of one draft (`GET /v1/workflow-edit-locks/:id`, and the
+ * `workflow_edit_lock_changed` event). One machine edits a draft at a time.
+ */
+interface EditLockView {
+    workflow_id: string;
+    /** `local`: one machine. `pending`: a takeover the holder has not answered yet. */
+    state: 'local' | 'here' | 'there' | 'pending';
+    /** The machine that edits while this one may not. */
+    holder: {
+        label: string;
+        since: number | null;
+    } | null;
+    /** A draft of this machine whose right was lost before it reached the account. */
+    lost: {
+        rev: number;
+        nodes: number;
+        kept_at: number;
+    } | null;
+}
+/** A machine of the space as this machine knows it. */
+interface SpaceMachine {
+    /** What a start names in `run_on`. */
+    binding: string;
+    /**
+     * The machine's name: the account's name for it when the control plane
+     * listed it, else the one it wrote itself; `null` without either.
+     */
+    label: string | null;
+    this_pc: boolean;
+    /** The space key is not open on that machine; `null` when nobody says. */
+    locked: boolean | null;
+    /** When the control plane last saw it read the space, unix seconds; `null` when it did not list it. */
+    seen_at: number | null;
+}
+/** Where one profile's starts go. */
+interface ProfileHome {
+    profile_id: string;
+    binding: string;
 }
-/** A row of the proxy LIST: the proxy plus who uses it. The single GET has no `used_by`. */
-interface ProxyRow extends Proxy {
-    used_by: ProxyUsage;
+/**
+ * This machine, every machine the control plane lists for the space and every
+ * machine that is home to a profile, then the home of each profile
+ * (`GET /v1/workflow-sync/machines`). Empty on a machine without an account.
+ */
+interface WorkflowMachines {
+    machines: SpaceMachine[];
+    homes: ProfileHome[];
+    /**
+     * The control plane's list is in `machines`. `false` when it did not answer
+     * or refused: then a machine that is home to no profile is missing.
+     */
+    complete: boolean;
 }
-/** Per-detector outcome; `skip` means the page could not be evaluated, NOT a pass. */
-type AuditVerdict = 'pass' | 'warn' | 'fail' | 'skip' | 'error';
-interface AuditDetectorReport {
-    id: string;
-    verdict: AuditVerdict;
-    detail: string;
+
+/** A workflow shared by link: the link to hand on, and the id that revokes it. */
+interface WorkflowShareLink {
+    share_id: string;
+    /**
+     * The link to send. Its fragment carries the key that opens the copy, so the
+     * link is the whole secret: anyone who holds it can open it until it is revoked.
+     */
+    link: string;
 }
-interface AuditReport {
-    schema_version: number;
-    timestamp: string;
-    overall: AuditVerdict;
-    detectors: AuditDetectorReport[];
+/** The copy a link opened. It asks a person's trust before its first start. */
+interface ImportedWorkflow {
+    workflow_id: string;
+    name: string;
+    /** Who shared it, as that sender's account names them. */
+    author_name: string;
 }
-interface AuditStatus {
-    profile_id: string;
-    /** `idle` (never run since the daemon started), `running`, or `finished`. */
-    state: 'idle' | 'running' | 'finished';
-    started_at?: number;
-    finished_at?: number;
-    /** Why the RUN failed, distinct from a detector's own `skip`. */
-    error?: string;
-    report?: AuditReport;
+/** What revoking a link answers. Copies already made stay. */
+interface ShareRevoked {
+    share_id: string;
+    revoked: boolean;
 }
-interface CreateGroupBody {
+/** One ready-made starting point from the template catalog. */
+interface WorkflowTemplate {
+    id: string;
     name: string;
+    description: string;
 }
-type UpdateGroupBody = Partial<CreateGroupBody>;
-interface CreatePresetBody {
+/** The workflow a template made. */
+interface InstantiatedTemplate {
+    workflow_id: string;
     name: string;
-    constraints?: PresetConstraints;
-    config?: PresetConfig;
 }
-type UpdatePresetBody = Partial<CreatePresetBody>;
-interface SessionExportBody {
-    password: string;
-    kinds?: SessionKind[];
+
+/**
+ * How a workflow space protects its run summaries: `readable` at the account's
+ * server, or `e2e` (end-to-end encrypted, readable only on the owner's own
+ * machines and phones).
+ */
+type WlBriefMode = 'readable' | 'e2e' | (string & {});
+/** What a client app shares with its agency, and whether it is connected to one. */
+interface WlSharing {
+    /** `true` once this app is connected to an agency with its activation code. */
+    activated: boolean;
+    /** The agency's name; `null` before an activation. */
+    agency: string | null;
+    /** Whether the agency may read this machine's tables. */
+    tables: boolean;
+    /** Whether the agency may see screenshots from this machine. */
+    screens: boolean;
+    /** Whether the agency may see the list of this machine's profiles. */
+    profiles: boolean;
+    /** Shown only: the agency switches it (see `setClientBriefMode`). */
+    brief_mode: WlBriefMode;
+    /**
+     * A device claim that failed after the activation and is tried again in the
+     * background; `null` when none waits.
+     */
+    device_claim: WlDeviceClaim | null;
 }
-interface SessionExportResult {
-    bundle: string;
+/** A device claim the daemon tries again, a bounded number of times. */
+interface WlDeviceClaim {
     /**
-     * Whether the cookies came out of the RUNNING browser for this export.
-     *
-     * `false` means the bundle carries only what was stored earlier, which for a
-     * stopped profile is all there can be: a browser holds its jar in its own
-     * process. Export while the profile runs for a current session.
+     * `retrying`; `gave_up` until the daemon restarts; or `needs_new_code` when the
+     * account's server refused the claim for good (the approval expired, was used or
+     * is missing): only a new activation code from the agency helps then.
      */
-    harvested?: boolean;
-    /** Why the bundle is thinner than it could be, when it is. */
-    note?: string;
+    state: 'retrying' | 'gave_up' | 'needs_new_code' | (string & {});
+    /** The server's refusal code with `needs_new_code`, such as `APPROVAL_EXPIRED`; else `null`. */
+    code: string | null;
+    attempts: number;
+    last_error: string | null;
+    /** Seconds to the next try while `retrying`. */
+    next_try_in_s: number | null;
+}
+/** The kind of model source an agency key is for, and its model and address. */
+interface AgencyAiKeyOptions {
+    /** Without it each client keeps the key but makes no model source of it. */
+    kind?: 'api_anthropic' | 'api_openai' | 'api_compatible';
+    model?: string;
+    /** For `api_compatible` only. */
+    baseUrl?: string;
 }
-interface SessionImportBody {
-    password: string;
-    bundle: string;
+/** The scopes to change; a scope left out stays as it is. */
+interface SetWlSharingBody {
+    tables?: boolean;
+    screens?: boolean;
+    profiles?: boolean;
+}
+/** One end customer, as an agency machine sees it. */
+interface AgencyClient {
+    id: string;
+    /** The name the agency gave the client. */
+    name: string;
+    /** `active`, or `revoked` once the agency removed the client. */
+    status: 'active' | 'revoked' | (string & {});
+    /** Whether the client runs on two or more PCs. */
+    multi_pc: boolean;
+    /** The mode the client's own machine reported last. */
+    brief_mode: WlBriefMode;
+    /**
+     * The mode this agency switched the client to that the client's machine has
+     * not reported yet; `null` when both agree or the agency never switched it.
+     */
+    brief_mode_requested: 'readable' | 'e2e' | null;
+    space_id: string;
+    dist_space_id: string;
+    /** The PCs activated for this client. */
+    machines: number;
+    /** The ids of the workflows handed on to this client. */
+    workflows: string[];
+}
+/** The agency's white-label seats: booked and taken. */
+interface AgencySeats {
+    limit: number;
+    used: number;
+}
+interface AgencyClientList {
+    clients: AgencyClient[];
+    /** The agency's seats; `null` when the control plane named none. */
+    seats: AgencySeats | null;
+}
+/** What handing workflows to a client answers. */
+interface AgencyDistribution {
+    client_id: string;
+    /** How many workflows went out. */
+    workflows: number;
+}
+/** What switching a client's mode answers. */
+interface ClientBriefModeSet {
+    client_id: string;
+    brief_mode: 'readable' | 'e2e';
 }
 /**
- * Trusted-input payload (`POST /v1/profiles/:id/input`). Only
- * `action` and `humanize` are fixed by the API contract; the per-action
- * coordinate fields below are the SDK's assumption about the daemon's input
- * layer.
+ * The brand the app draws (`GET /v1/brand`, `brand_changed`): an agency's name,
+ * accent and logo in a white-label app, else the product's own.
  */
-type TrustedInputBody = {
-    action: 'move';
-    x: number;
-    y: number;
-    width?: number;
-    humanize?: boolean;
-} | {
-    action: 'click';
-    x: number;
-    y: number;
-    button?: string;
-    click_count?: number;
-    width?: number;
-    humanize?: boolean;
-} | {
-    action: 'type';
-    text: string;
-    humanize?: boolean;
-} | {
-    action: 'scroll';
-    x: number;
-    y: number;
-    delta_x?: number;
-    delta_y?: number;
-    humanize?: boolean;
-};
-/** Who is driving: an agent holding a lease, or a person at a window. */
-type RunActor = 'agent' | 'human';
-/** How a run ended. `reached`/`partial` appear only when a source claimed it. */
-type RunOutcome = 'running' | 'reached' | 'partial' | 'blocked' | 'interrupted' | 'unknown';
-/** What kind of thing a trail entry is. */
-type StepKind = 'page' | 'action' | 'interruption';
-/** The element a step acted on, as it can still be recognised later. */
-interface StepTarget {
-    role: string;
+interface BrandView {
+    /** `true` for an agency's brand, `false` for the product's own. */
+    custom: boolean;
     name: string;
-}
-/** One tool call, as the operator gets to read it back. */
-interface RunStep {
-    /** Position within the run, starting at 1. */
-    seq: number;
-    at: number;
-    duration_ms: number | null;
-    kind: StepKind;
-    /** The tool name; `null` for a synthetic `page` step. */
-    tool: string | null;
-    target: StepTarget | null;
-    /** A short human line. Carries typed text unless `redacted`. */
-    summary: string | null;
-    redacted: boolean;
-    /** Set on `page` steps. */
-    url: string | null;
-    /** Path of the still under the runs API; the image is fetched separately. */
-    shot_path: string | null;
+    /** `#rrggbb`, or `null` for the product's own colours. */
+    accent: string | null;
+    /** Where the logo is, or `null` for the product's own mark. */
+    logo_url: string | null;
     /**
-     * What the call produced, in one line: "3 blocks, 122 characters",
-     * "no visible change · 14 elements".
-     *
-     * `summary` says what the agent asked for, this says what came back. A step
-     * recorded before this field existed has `null`.
+     * Why the last brand file fetched did not count (`bad_signature`, `expired`,
+     * `other_machine`, `logo_mismatch`, ...); the brand shown is then the last good one.
      */
-    result: string | null;
-    error: string | null;
-}
-/** What one running profile is showing. */
-interface ProfileActivity {
-    profile_id: string;
-    profile_name: string;
-    url: string;
-    title: string;
-    actor: RunActor;
-    /** Unix seconds this address was first seen. */
-    since: number;
-    /** The browser did not answer the last sweep; this is the last known value. */
-    stale: boolean;
-}
-/** How far a claim reaches. `machine` means this computer has no account key yet. */
-type ExitScope = 'machine' | 'account';
-/** One exit address a profile owns. */
-interface ExitClaim {
-    /** The comparison unit: the whole address for IPv4, the `/64` block for IPv6. */
-    addr: string;
-    /** `mobile` | `residential` | `datacenter` | `unknown`. Sets how long it is held. */
-    class: string;
-    scope: ExitScope;
-    first_seen: number;
-    last_seen: number;
-    expires_at: number;
-}
-/** A profile's exit-address situation. */
-interface ExitStatus {
-    /** Whether the rule applies to this installation at all. */
-    enabled: boolean;
-    /** Derived from the newest claim, not from configuration. */
-    scope: ExitScope;
-    /** The IPv4 address in use, when one is claimed. Carries its `v4:` prefix. */
-    current: string | null;
+    problem: string | null;
     /**
-     * The IPv6 `/64` in use, when the daemon measures v6 (`[exit] probe_url_v6`)
-     * and the exit answered over it. `null` is the ordinary case and says nothing
-     * about the exit: without that setting the guard never asks.
+     * The update channel the brand file names, which the desktop app follows at runtime;
+     * `null` for the app's own feed. Every installer still has to carry the pinned release
+     * signature.
      */
-    current_v6: string | null;
-    /** How many addresses this profile owns. Both families count. */
-    owned: number;
-    claims: ExitClaim[];
-    /** Set when the profile has no proxy and is therefore exempt. */
-    note: string | null;
+    update_feed: string | null;
 }
 
+type VersionKind = 'saved' | 'restore' | 'repair' | 'rollback' | (string & {});
+type AuthorKind = 'human' | 'ai' | 'repair' | 'system' | (string & {});
+/** One version of a workflow. A version never changes. */
+interface WorkflowVersion {
+    id: string;
+    number: number | null;
+    kind: VersionKind;
+    note: string | null;
+    author_kind: AuthorKind;
+    contributors: string[];
+    change_count: number;
+    published: boolean;
+    created_at: number;
+}
+/** One version whole: its row and its graph document. */
+interface WorkflowVersionDoc {
+    version: WorkflowVersion;
+    doc: WorkflowDoc;
+}
+interface SaveWorkflowVersionBody {
+    note?: string;
+}
+/** Saving the same content twice is one version: the second answer is `unchanged`. */
+type SaveOutcome = {
+    created: {
+        version_id: string;
+        number: number;
+    };
+} | {
+    unchanged: {
+        version_id: string;
+    };
+};
+interface RevertWorkflowBody {
+    /** The version whose content the draft takes back. */
+    version_id: string;
+    /** The new version's note; default "Restored from version N". */
+    note?: string;
+}
+/** What restoring a version did. */
+interface RevertResult {
+    /** The number of the version restored. */
+    restored_from: number | null;
+    /** The draft's revision afterwards. */
+    rev: number;
+    /** The batch that set the draft; `null` when the draft held that content already. */
+    batch_id: string | null;
+    /** The version the restored content was saved as. */
+    saved: SaveOutcome;
+}
+interface DiffWorkflowParams {
+    /** The older version. */
+    from: string;
+    /** The newer version; without it, the draft. */
+    to?: string;
+}
+/** One node as a change list names it. */
+interface DiffNode {
+    id: NodeId;
+    type: string;
+    name: string;
+}
+/** A node in both versions whose content differs. */
+interface DiffNodeChange {
+    id: NodeId;
+    name: string;
+    /** `type`, `name`, `intent`, `region`, `base.<key>`, `settings.<key>`, `extra.<key>`. */
+    fields: string[];
+}
+/** One edge as a change list names it. */
+interface DiffEdge {
+    id: string;
+    from: NodeId;
+    port: string;
+    to: NodeId;
+}
+/** What changed from one version to another, or from a version to the draft. */
+interface WorkflowDiff {
+    /** The number of the older version. */
+    from: number | null;
+    /** The number of the newer version, or `draft`. */
+    to: number | 'draft' | null;
+    added_nodes: DiffNode[];
+    removed_nodes: DiffNode[];
+    changed_nodes: DiffNodeChange[];
+    /** Nodes whose position alone changed: layout, not counted. */
+    moved_nodes: NodeId[];
+    added_edges: DiffEdge[];
+    removed_edges: DiffEdge[];
+    /** Top-level keys of the workflow settings that changed. */
+    settings: string[];
+    groups: string[];
+    notes: string[];
+    extra: string[];
+    /** Every change except a move. */
+    count: number;
+}
+type VariableScope = 'workflow' | 'profile' | (string & {});
 /**
- * The per-profile task list and the profile's own durable memory.
- *
- * One of the files that are the daemon's wire contract.
+ * One variable's value as a list shows it. A value of a `secret` variable, or
+ * a marked one, is only ever `{ withheld: label }` here.
  */
+interface VariableState {
+    var_id: string;
+    name: string;
+    type: string;
+    scope: VariableScope;
+    /** The profile whose value this is; `null` for the whole workflow, or for the default a profile without its own reads. */
+    profile_id?: string | null;
+    value: unknown;
+    updated_at: number;
+    updated_by_run?: string | null;
+}
+interface SetWorkflowVariableBody {
+    value: unknown;
+    /** The profile whose value this is, for a variable of scope `profile`. */
+    profile_id?: string;
+}
+interface RevealWorkflowVariableBody {
+    vault_password: string;
+    profile_id?: string;
+}
+interface RevealedVariable {
+    var_id: string;
+    value: unknown;
+}
+
+/** A node of a workflow graph, as stored: `n_` and a number that only grows. */
+type NodeId = `n_${number}`;
+/** One step on the canvas. Unknown keys from a newer daemon are kept. */
+interface WorkflowNode {
+    type: string;
+    v: number;
+    name: string;
+    /** One plain sentence: what this step is for. */
+    intent: string;
+    base: Record<string, unknown>;
+    settings: Record<string, unknown>;
+    region_end?: NodeId;
+    region_start?: NodeId;
+    ui: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface WorkflowEdge {
+    from: NodeId;
+    port: string;
+    to: NodeId;
+    [key: string]: unknown;
+}
+/** The whole graph document (format 1). */
+interface WorkflowDoc {
+    format: number;
+    next_node: number;
+    next_edge: number;
+    settings: Record<string, unknown>;
+    nodes: Record<NodeId, WorkflowNode>;
+    edges: Record<string, WorkflowEdge>;
+    groups: Record<string, unknown>;
+    notes: Record<string, unknown>;
+    [key: string]: unknown;
+}
+type DiagnosticSeverity = 'error' | 'warning' | 'info';
+/** A finding about a document. `error` blocks saving a version and starting. */
+interface Diagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    node_id?: NodeId;
+    field_path?: string;
+    message: string;
+    fix?: EditOp;
+    candidates?: string[];
+}
 /**
- * Where a task stands.
- *
- * Four words and no more. There is deliberately no `blocked` and no `partial`:
- * `in_progress` already carries "somebody tried and did not finish", and why it
- * failed belongs in the run trail, which is built to hold exactly that.
- *
- * `cancelled` is `done` with a different word. Both are endings, both fall out
- * of the list a day later; the separate word is so a reader can tell "we did it"
- * from "we called it off".
+ * One edit op. The `op` names the change (`add_node`, `connect`, `rename`,
+ * `update_settings`, …); its other fields depend on it. A batch of ops applies
+ * whole or not at all.
  */
-type TaskState = 'open' | 'in_progress' | 'done' | 'cancelled';
-/** One task on one profile. */
-interface ProfileTask {
+interface EditOp {
+    op: string;
+    [key: string]: unknown;
+}
+type CodeTrust = 'not_needed' | 'required' | 'granted';
+interface CodeRights {
+    unlocked: boolean;
+    network: boolean;
+    files: boolean;
+    programs: boolean;
+}
+/** The latest run of a workflow, as a list line names it. */
+interface RunBrief {
+    run_id: string;
+    status: WorkflowRunStatus;
+    status_reason: WorkflowStatusReason | null;
+    enqueued_at: number;
+    finished_at: number | null;
+}
+/** One workflow in a list. */
+interface WorkflowSummary {
     id: string;
-    profile_id: string;
-    /** Carried along so a fleet-wide list can say whose task a row is. */
-    profile_name: string;
+    name: string;
+    /** The draft's revision; an edit names the revision it read as `base_rev`. */
+    rev: number;
+    /** The number of the published version, `null` while nothing is published. */
+    published_version: number | null;
+    /** The draft differs from the version it was last saved as. */
+    draft_dirty: boolean;
     /**
-     * The IANA zone `due_at` should be READ in: the profile's own.
-     *
-     * Without it a viewer reads their own clock and acts on the wrong number, and
-     * an account posting at three in the morning local time is exactly the
-     * behavioural tell this product avoids everywhere else. Derived at query time,
-     * never stored on the task: `geo_mode = follow_exit` rewrites the persona's
-     * zone at every launch.
+     * The number of the version the draft was last saved as; `null` before the
+     * first save. Absent from a daemon up to 0.25.1.
      */
-    profile_timezone: string | null;
-    /** One line saying what to do. A task names its material, it does not hold it. */
-    title: string;
-    state: TaskState;
+    draft_base_version?: number | null;
     /**
-     * Deadline in unix seconds (UTC), or `null` for work that is owed but not owed
-     * at any particular moment.
-     *
-     * Read it in the PROFILE's timezone, not the viewer's: a task due at nine means
-     * nine where the identity lives, and an account that posts at three in the
-     * morning local time is a behavioural tell.
-     *
-     * It is a deadline, not a trigger. Nothing runs by itself.
+     * The repair versions above the draft's base that the draft does not carry
+     * yet, newest first. Absent from a daemon up to 0.25.1.
+     */
+    repairs_to_adopt?: RepairToAdopt[];
+    /**
+     * The repair versions above the draft's base that the draft carries, newest
+     * first; each is undone with `undoWorkflowBatch(id, batch_id)` until a version
+     * is saved. Absent from a daemon up to 0.25.1.
+     */
+    repairs_applied?: RepairApplied[];
+    /** The trigger types that start it: the published version's, else the draft's. */
+    triggers: string[];
+    origin: 'own' | 'shared' | 'agency' | 'template' | (string & {});
+    /** The sender's name on a copy from a link (`origin: shared`); `null` on every other workflow. */
+    author_name: string | null;
+    code_trust: CodeTrust;
+    /**
+     * `true` when the next start asks a person to trust this workflow once
+     * (`code_trust: required`); the start answers 409 `code_trust_required` until then.
+     */
+    trust_required: boolean;
+    trust_reasons: ('code' | 'outbound' | 'notify' | (string & {}))[];
+    code_rights: CodeRights;
+    /** Run events given up after five tries. */
+    notify_failed: number;
+    last_run: RunBrief | null;
+    updated_at: number;
+}
+/**
+ * A version the repair published that the draft does not carry yet.
+ * `adoptWorkflowVersion(workflowId, version_id)` takes it over into the
+ * draft as one batch of the repair; `undoWorkflowBatch(workflowId, batch_id)`
+ * takes that batch back and offers it again.
+ */
+interface RepairToAdopt {
+    version_id: string;
+    number: number;
+    /** The steps the repair changed against the version it was made from. */
+    nodes: NodeId[];
+    /**
+     * Of those, the steps the draft holds otherwise or a person has open in the
+     * editor: taking the repair over leaves them as they are.
      */
-    due_at: number | null;
-    created_at: number;
-    /** When the current claim was taken; cleared when the task leaves `in_progress`. */
-    claimed_at: number | null;
-    finished_at: number | null;
+    conflicts: NodeId[];
+}
+/**
+ * A version the repair published that the draft carries: `undoWorkflowBatch(workflowId,
+ * batch_id)` takes it back, and it is offered in `repairs_to_adopt` again.
+ */
+interface RepairApplied {
+    version_id: string;
+    number: number;
+    /** The batch of the repair that took it over. */
+    batch_id: string;
+    /** The steps that batch changed. */
+    nodes: NodeId[];
+    /** The steps of the repair it left as they were in the draft. */
+    left: NodeId[];
+}
+/** A workflow in full: its summary, the draft and what the checks find in it. */
+interface WorkflowDetail {
+    workflow: WorkflowSummary;
+    rev: number;
+    doc: WorkflowDoc;
+    diagnostics: Diagnostic[];
+}
+interface GetWorkflowParams {
     /**
-     * Set when a claim nobody finished was handed back after six hours.
-     *
-     * Whoever picks such a task up has to check whether the work already happened:
-     * the previous run may have published the post and died before it could say so.
+     * `stored` (the default) or `text`: every node's settings in the text form
+     * the editor and an edit write, references as `{{#12.phone}}`.
      */
-    last_attempt_at: number | null;
+    form?: 'stored' | 'text';
 }
-/** Filters for listing tasks. All are narrowings; absent means unconstrained. */
-interface ListTasksParams {
-    profile_id?: string;
-    state?: TaskState;
-    /** Only tasks whose deadline is at or before this unix second. */
-    due_before?: number;
-    /** Substring of the title, case-insensitive. */
-    q?: string;
-    limit?: number;
-    offset?: number;
+/** One value a field may point at: the key after the step's number or the scope, its name, its type. */
+interface ReferenceOutput {
+    key: string;
+    label: string;
+    type: 'text' | 'number' | 'boolean' | 'list' | 'url' | 'date' | 'object' | 'file' | 'secret' | 'any' | (string & {});
 }
-/** Add the same task to one or many profiles, one row each. */
-interface CreateTasksBody {
-    profile_ids: string[];
+/**
+ * An earlier step with the values it declares (`reference` is its number), or
+ * one of the workflow's scopes (`var`, `input`, `run`): the form of the design
+ * system's `ReferenceSource`.
+ */
+type ReferenceSource = {
+    reference: number;
+    label: string;
+    outputs: ReferenceOutput[];
+} | {
+    scope: 'var' | 'input' | 'secret' | 'run' | (string & {});
+    label: string;
+    outputs: ReferenceOutput[];
+};
+interface CreateWorkflowBody {
+    name: string;
+}
+interface EditWorkflowBody {
+    /** The revision the batch was built on. */
+    base_rev: number;
+    ops: EditOp[];
+    /** One sentence for the batch log: what this batch is for. */
+    intent?: string;
+    /** Decide and answer without storing. */
+    dry_run?: boolean;
+}
+/** What an applied batch did. */
+interface EditResult {
+    applied: boolean;
+    rev: number;
+    batch_id: string;
+    /** Temporary names of the batch to the node ids they got. */
+    id_map: Record<string, NodeId>;
+    changed_node_ids: NodeId[];
+    diagnostics: Diagnostic[];
+}
+/** Move a part of the draft into a workflow of its own. */
+interface ExtractWorkflowBody {
+    /** The draft's revision the part was chosen at. */
+    base_rev: number;
+    /** The part, one id per step. */
+    node_ids: NodeId[];
+    /** The new workflow's name. */
+    name: string;
+}
+/** The new workflow and the source after a part of it moved there. */
+interface ExtractResult {
+    subflow_id: string;
+    /** The source draft's revision after the batch. */
+    rev: number;
+    /** The "Run Workflow" step now standing where the part was. */
+    node_id: NodeId;
+    /** One input per value the part read from outside. */
+    inputs: string[];
+    /** One result field per value a later step read from the part. */
+    outputs: string[];
+}
+interface DeleteWorkflowParams {
+    /** What happens to tables only this workflow uses. */
+    tables?: 'keep' | 'trash';
+}
+/** One declared output of a node type, as a reference names it: `{{#7.phone}}`. */
+interface NodeTypeOutput {
+    key: string;
+    label: string;
+    type: 'text' | 'number' | 'boolean' | 'date' | 'list' | 'object' | 'file' | 'secret' | 'any' | 'table' | (string & {});
+    /** Carries a marked value: never shown, never sent out. */
+    marked: boolean;
+}
+/** One node type of the catalog. */
+interface NodeTypeInfo {
+    type: string;
+    version: number;
+    group: 'trig' | 'prof' | 'nav' | 'act' | 'read' | 'logic' | 'data' | 'id' | 'ai' | 'ext' | 'tool' | (string & {});
     title: string;
-    due_at?: number | null;
+    /** The glyph the editor draws for this type, a name of the design system's icon set. */
+    icon: string;
+    /** One English sentence: what a node of this type does. */
+    one_line: string | null;
+    kind: 'trigger' | 'step' | 'branch' | 'loop' | 'loop_end' | 'end' | (string & {});
+    /** The output ports, for empty settings where `ports_from` names a setting. */
+    ports: string[];
+    ports_from: 'branches' | 'answers' | 'end_run' | null;
+    /** Whether an edge comes in. */
+    input: boolean;
+    region: {
+        opens: string;
+    } | {
+        closes: string;
+    } | {
+        fleet_body: string;
+    } | null;
+    effect: string;
+    default_risk: 'read' | 'reversible' | 'irreversible' | null;
+    /**
+     * JSON Schema of the settings. `x-template: true` marks a value that may carry
+     * references, `x-human-only: true` one only a person changes.
+     */
+    schema: Record<string, unknown> | null;
+    outputs: NodeTypeOutput[];
+    /** `inputs`: one more output per start input; `row`: one per column of the table read. */
+    dynamic_outputs: 'inputs' | 'row' | null;
+    /** Whether a run executes this type today; otherwise a run stops there with `executor_missing`. */
+    runnable: boolean;
+}
+interface ListNodeTypesParams {
+    group?: string;
+    query?: string;
 }
-/** What one create call did. */
-interface CreateTasksResult {
-    created: ProfileTask[];
+
+/** Where a repair's fix stands. A value a newer daemon adds reads as a plain string. */
+type PatchState = 'probe' | 'proposal' | 'published' | 'confirmed' | 'rolled_back' | 'reverted' | 'superseded' | (string & {});
+/** One fix a repair made, kept on the machine that made it. */
+interface RepairPatch {
+    id: string;
+    workflow_id: string;
+    base_version_id: string;
+    node_id: string;
+    fleet_key: string;
+    /** The edit ops of the fix, one batch with the repair as author. */
+    ops: EditOp[];
+    /** The ops that undo them. */
+    inverse: EditOp[];
+    risk: 'read' | 'reversible' | 'irreversible';
+    state: PatchState;
+    probe_needed: number;
+    probe_passed: number;
+    probe_profiles: string[];
+    /** This machine's executions of the fix. */
+    executions: number;
+    failures_first10: number;
+    clean_runs: number;
+    approval_id: string | null;
+    published_version_id: string | null;
+    /** The `rollback` version after a rollback or a revert. */
+    counter_version_id: string | null;
+    created_at: number;
+    updated_at: number;
     /**
-     * Profiles that no longer exist. Named rather than dropped: adding a task to
-     * twenty profiles of which three were deleted writes seventeen rows and says
-     * which three it could not.
+     * In the list only: a person's newer version changed the repaired node
+     * since the fix's base, so the fix stays a proposal.
      */
-    missing: string[];
+    conflict?: boolean;
 }
-/** The one transition this surface performs. */
-interface PatchTaskBody {
-    /** Only `cancelled`, and only on a task nobody has claimed. */
-    state: 'cancelled';
+/** One call of the repair at one place of one run. */
+interface RepairAttempt {
+    id: string;
+    run_id: string;
+    workflow_id: string;
+    version_id: string;
+    node_id: string;
+    iter_key: string;
+    profile_id: string;
+    fleet_key: string;
+    /** `transient`, `account_state`, `locator_drift`, `broken_reference`, `effect_unclear`. */
+    failure_class: string;
+    /** `ladder:<rung>`, `ai`, `run_patch` or `none`. */
+    resolved_by: string;
+    /** `applied`, `escalated`, `account_state`, `parked` (another run's model phase held the fleet lock). */
+    verdict: string;
+    patch_id: string | null;
+    started_at: number;
+    ended_at: number | null;
+    wall_ms: number | null;
+}
+/** One fix with the attempts that made or used it. */
+interface RepairView {
+    repair: RepairPatch;
+    attempts: RepairAttempt[];
+}
+/** A fix taken back: the version `rollback`, now published, and what it left. */
+interface RevertedRepair {
+    repair: RepairPatch;
+    version_id: string;
+    /** Elements left as they were because they changed after the repair, such as `n_12`. */
+    skipped_changed: string[];
+}
+/** A repair's version taken over into the draft. */
+interface AdoptResult {
+    /** False when every part of the fix met a node a person changed or has open. */
+    applied: boolean;
+    /** The draft's revision afterwards. */
+    rev: number;
+    /** The batch of the repair in the draft; one undo takes it back. */
+    batch_id: string | null;
+    /** Nodes left as the person made them, such as `n_12`. */
+    conflicts: string[];
+}
+/** The kinds of model source. */
+type SourceKind = 'api_anthropic' | 'api_openai' | 'api_compatible' | 'agent_claude_code' | 'agent_codex' | 'agent_copilot' | (string & {});
+/** A model source as the daemon shows it: never the key, only `key_hint`. */
+interface AiSource {
+    id: string;
+    kind: SourceKind;
+    label: string;
+    auth: 'api_key' | 'subscription';
+    model: string | null;
+    base_url: string | null;
+    cli_path: string | null;
+    price_in_micros: number | null;
+    price_out_micros: number | null;
+    /** The key's last four characters, such as `…abcd`. */
+    key_hint: string | null;
+    origin: 'own' | 'agency';
+    capabilities: {
+        tools?: boolean | null;
+        json_schema?: boolean | null;
+        vision?: boolean | null;
+        sampling?: boolean | null;
+    };
+    enabled: boolean;
+    /** What this machine measured; `null` until checked. */
+    health: {
+        checked_at: number;
+        state: string;
+        cli_version: string | null;
+        exhausted_until: number | null;
+        detail: string | null;
+    } | null;
+    created_at: number;
+    updated_at: number;
 }
-/**
- * A profile's durable memory: the `PROFILE.md` at the top of its directory.
- *
- * Same purpose as a repository's `CLAUDE.md`. What goes in it is the customer's
- * business; nothing writes a scaffold or seeds a value, and a profile starts with
- * no file rather than an empty one.
- */
-interface ProfileMemory {
-    /** `null` while nobody has written one. */
-    content: string | null;
-    /** The absolute path, so a person can open it in their own editor. */
-    path: string;
-    updated_at: number | null;
-    /** The ceiling a write is measured against, in bytes. */
-    max_bytes: number;
+/** A new model source; `api_key` is written once and never read back. */
+interface CreateAiSourceBody {
+    kind: SourceKind;
+    label: string;
+    auth?: 'api_key' | 'subscription';
+    model?: string;
+    base_url?: string;
+    cli_path?: string;
+    price_in_micros?: number;
+    price_out_micros?: number;
+    api_key?: string;
+    enabled?: boolean;
+}
+/** A change to a model source; `null` clears a field, an absent one stays. */
+interface UpdateAiSourceBody {
+    label?: string;
+    model?: string | null;
+    base_url?: string | null;
+    cli_path?: string | null;
+    enabled?: boolean;
+    /** Replaces the key. */
+    api_key?: string;
+}
+/** The account's model settings. */
+interface AiSettings {
+    /** Source ids; the first is the default source. */
+    default_order: string[];
+    /** Runs of each subscription agent at once on one machine. */
+    sub_limits: Record<string, number>;
+    updated_at: number;
 }
-/** Replace a profile's memory. The text is stored verbatim. */
-interface WriteMemoryBody {
-    content: string;
+/** One model call of a run. */
+interface AiInvocation {
+    id: string;
+    run_id: string | null;
+    workflow_id: string | null;
+    node_id: string | null;
+    iter_key: string | null;
+    repair_id: string | null;
+    /** `ask`, `extract`, `decide`, `agent_step`, `arbiter`, `repair`, `canary`, `probe`. */
+    purpose: string;
+    source_id: string;
+    source_kind: string;
+    /** The model that really answered. */
+    model: string | null;
+    cli_version: string | null;
+    /** The source before this one when the chain fell back, and how it ended. */
+    fallback_from: string | null;
+    fallback_reason: string | null;
+    status: string;
+    usage_in: number;
+    usage_out: number;
+    usage_cache_read: number;
+    usage_cache_write: number;
+    /** `null`: unknown. */
+    cost_micros: number | null;
+    /** `computed`, `reported` or `unknown`. */
+    cost_source: string;
+    billing: string;
+    page_effects: number;
+    denials: number;
+    started_at: number;
+    ended_at: number | null;
+}
+/** Filters of the model calls; `since` in Unix seconds. */
+interface AiInvocationsParams {
+    run_id?: string;
+    workflow_id?: string;
+    since?: number;
+    /** 1 to 1000, default 200. */
+    limit?: number;
+}
+/** A share with its base and the upper bound of a 95 % Wilson interval; `null` without a base. */
+interface RepairRate {
+    k: number;
+    n: number;
+    rate: number | null;
+    upper_95: number | null;
+}
+/** Nearest-rank percentiles; `null` without values. */
+interface RepairSpread {
+    p50: number | null;
+    p95: number | null;
+}
+/** The repair's key figures of one workflow version and node. */
+interface RepairNodeFigures {
+    version_id: string;
+    node_id: string;
+    executions: number;
+    attempts: number;
+    /** Repair attempts per execution of the node. */
+    trigger: RepairRate;
+    /** Attempts the fixed ladder settled without a model. */
+    fixed: RepairRate;
+    /** Attempts with a model that ended applied. */
+    success: RepairRate;
+    /** Fixes rolled back, or taken back by a person within 14 days, per fix. */
+    false_repair: RepairRate;
+    cost: {
+        api_key_micros: number;
+        subscription_micros: number;
+    };
+    wall_ms: RepairSpread;
+    approvals: {
+        count: number;
+        rejected: RepairRate;
+        answer_s: RepairSpread;
+    };
+    /** Model calls of the repair that fell back, by reason. */
+    fallback: Record<string, number>;
+}
+/** `GET /v1/workflow-repair-metrics`: one workflow over the last `days` days. */
+interface RepairFigures {
+    workflow_id: string;
+    days: number;
+    since: number;
+    nodes: RepairNodeFigures[];
 }
 
+/** A draft batch as `workflow_draft_changed` names it. */
+interface DraftBatchBrief {
+    id: string;
+    author: 'human' | 'ai' | 'repair' | 'sync' | (string & {});
+    intent: string | null;
+    at: number;
+}
 /**
  * A daemon lifecycle event. Named `LifecycleEvent` (not `Event`) to avoid
  * clashing with the global `Event`; also re-exported as `Event` for parity with
@@ -1147,6 +2868,12 @@ type LifecycleEvent = {
     profile_id: string;
     at: number;
 }
+/** The subscription's concurrency limit refused a start (error 4008); the figures ride in the error. */
+ | {
+    type: 'concurrency_rejected';
+    profile_id: string;
+    at: number;
+}
 /** An agent declared a task on a profile, or one was opened for undeclared work. */
  | {
     type: 'run_started';
@@ -1222,9 +2949,26 @@ type LifecycleEvent = {
     at: number;
 }
 /**
- * Frames were lost; re-read rather than carry on. Raised when the daemon
- * notices this connection fell behind. `dropped` counts what it skipped.
+ * A Secret Layer entry appeared or changed: the whole row, never a value.
+ * `count` is the profile's total after this event, so a reader can tell
+ * "I missed one" from "there is one".
  */
+ | {
+    type: 'secret_changed';
+    profile_id: string;
+    secret: SecretRow;
+    count: number;
+    at: number;
+}
+/** A Secret Layer entry is gone: deleted, expired, or swept out of quarantine. */
+ | {
+    type: 'secret_gone';
+    profile_id: string;
+    secret_id: string;
+    label: string;
+    count: number;
+    at: number;
+}
 /**
  * The exit-address guard's verdict for one running profile.
  *
@@ -1248,7 +2992,209 @@ type LifecycleEvent = {
     type: 'exit_guard_gone';
     profile_id: string;
     at: number;
-} | {
+}
+/** A workflow table appeared or changed (or came back from the bin): the whole row. */
+ | {
+    type: 'table_changed';
+    table: TableMeta;
+    at: number;
+}
+/** A workflow table left the list: to the bin, or for good. */
+ | {
+    type: 'table_gone';
+    table_id: string;
+    at: number;
+}
+/**
+ * Rows appeared or changed (whole rows, `claimed_by_run` while a run holds one)
+ * or left (`gone_rids`). With `resync` (over 500 at once) the rows are left
+ * out: re-read the table.
+ */
+ | {
+    type: 'table_rows_changed';
+    table_id: string;
+    rows: Row[];
+    gone_rids: string[];
+    resync: boolean;
+    at: number;
+}
+/** One value of a workflow variable appeared or changed: the whole entry. */
+ | {
+    type: 'variable_changed';
+    workflow_id: string;
+    variable: VariableState;
+    at: number;
+}
+/** A value left: one profile's, or with `profile_id: null` the variable with all its values. */
+ | {
+    type: 'variable_gone';
+    workflow_id: string;
+    var_id: string;
+    profile_id: string | null;
+    at: number;
+}
+/** A workflow appeared or changed: the whole summary. */
+ | {
+    type: 'workflow_changed';
+    workflow: WorkflowSummary;
+    at: number;
+}
+/** A workflow was deleted, with its draft, versions and runs. */
+ | {
+    type: 'workflow_gone';
+    workflow_id: string;
+    at: number;
+}
+/** A batch changed the draft: the elements it touched, whole, `null` for those it removed. */
+ | {
+    type: 'workflow_draft_changed';
+    workflow_id: string;
+    rev: number;
+    batch: DraftBatchBrief;
+    nodes: Record<string, WorkflowNode | null>;
+    edges: Record<string, WorkflowEdge | null>;
+    at: number;
+}
+/** A workflow run appeared or changed: the whole row. */
+ | {
+    type: 'workflow_run_changed';
+    run: WorkflowRun;
+    at: number;
+}
+/** A workflow run left the list (its workflow was deleted). */
+ | {
+    type: 'workflow_run_gone';
+    run_id: string;
+    workflow_id: string;
+    at: number;
+}
+/** A step of a workflow run began or ended: the whole stored step. */
+ | {
+    type: 'workflow_run_step';
+    step: WorkflowStep;
+    at: number;
+}
+/** A planned start appeared or changed: its whole row. */
+ | {
+    type: 'workflow_fire_changed';
+    fire: WorkflowFire;
+    at: number;
+}
+/** A planned start left the list: a week after its moment, or with its workflow. */
+ | {
+    type: 'workflow_fire_gone';
+    fire_id: string;
+    at: number;
+}
+/** A start that went to the machine its profile lives on appeared or changed: its whole row. */
+ | {
+    type: 'workflow_forward_changed';
+    forward: WorkflowForward;
+    at: number;
+}
+/** A forwarded start left: 30 days after it ended, or with its workflow. */
+ | {
+    type: 'workflow_forward_gone';
+    trigger_key: string;
+    at: number;
+}
+/** A switch was flipped: its whole row. */
+ | {
+    type: 'workflow_switch_changed';
+    switch: WorkflowSwitch;
+    at: number;
+}
+/** The fast mode's domain list changed: the whole list. */
+ | {
+    type: 'fast_domains_changed';
+    domains: FastDomain[];
+    at: number;
+}
+/** A Google connection appeared or changed (connected, a new grant, revoked, used): the whole connection, never a token. */
+ | {
+    type: 'connection_changed';
+    connection: GoogleConnection;
+    at: number;
+}
+/** A Google connection was removed. */
+ | {
+    type: 'connection_gone';
+    connection_id: string;
+    at: number;
+}
+/** An approval appeared or changed (opened, decided, expired, cancelled): the whole row. */
+ | {
+    type: 'approval_changed';
+    approval: Approval;
+    at: number;
+}
+/** A repair's fix appeared or changed (probe, published, confirmed, rolled back, reverted): the whole row. */
+ | {
+    type: 'repair_changed';
+    repair: RepairPatch;
+    at: number;
+}
+/** A repair's fix left the list. */
+ | {
+    type: 'repair_gone';
+    repair_id: string;
+    workflow_id: string;
+    at: number;
+}
+/** A model source appeared or changed: the whole view, never the key. */
+ | {
+    type: 'ai_source_changed';
+    source: AiSource;
+    at: number;
+}
+/** A model source was removed. */
+ | {
+    type: 'ai_source_gone';
+    source_id: string;
+    at: number;
+}
+/**
+ * What `GET /v1/brand` answers changed: a white-label app kept a new brand
+ * file, dropped one past its term, or refused one. The whole view; the brand
+ * always exists, so it has no `brand_gone`.
+ */
+ | {
+    type: 'brand_changed';
+    brand: BrandView;
+    at: number;
+}
+/**
+ * What `GET /v1/workflow-sync` answers changed: the whole view. A value that
+ * moves on its own (the clock offset, the backlog) arrives when it changed.
+ */
+ | {
+    type: 'workflow_sync_changed';
+    sync: WorkflowSyncView;
+    at: number;
+}
+/** The edit right of one draft changed: the whole view, naming its workflow. */
+ | {
+    type: 'workflow_edit_lock_changed';
+    lock: EditLockView;
+    at: number;
+}
+/** A row of the hook list appeared or changed: the whole row. */
+ | {
+    type: 'workflow_hook_changed';
+    hook: WorkflowHook;
+    at: number;
+}
+/** A workflow left the hook list: deleted, or its published version has no "Webhook" trigger. */
+ | {
+    type: 'workflow_hook_gone';
+    workflow_id: string;
+    at: number;
+}
+/**
+ * Frames were lost; re-read rather than carry on. Raised when the daemon
+ * notices this connection fell behind. `dropped` counts what it skipped.
+ */
+ | {
     type: 'resync';
     dropped: number;
     at: number;
@@ -1310,12 +3256,6 @@ declare function parseSseFrame(frame: string): StreamedEvent | null;
  */
 declare function eventStream(params: StreamParams): AsyncIterableIterator<LifecycleEvent>;
 
-/**
- * What the browser asks (interruptions), the bytes that go in and out
- * (artifacts), and what the licence says (account).
- *
- * One of the files that are the daemon's wire contract.
- */
 /** What an operator has taken out of an agent's hands. */
 type InterruptionLock = 'always_block' | 'always_allow' | 'agent_decides';
 /**
@@ -1373,6 +3313,73 @@ interface DeleteInterruptionRuleParams {
     kind: string;
     profile_id?: string | null;
 }
+/** One device a device chooser offers. Pass its `id` as `text` alongside `allow`. */
+interface InterruptionDevice {
+    id: string;
+    name: string;
+}
+/** A browser prompt waiting in a tab. */
+interface PendingInterruption {
+    /** The engine's token for this prompt. Pass it back to answer it. */
+    id: string;
+    /** A stable kind such as `notifications`, or `unknown` for a surface without a name. */
+    kind: string;
+    /** Chromium's own name for the request type. */
+    raw_kind: string;
+    origin: string;
+    embedding_origin: string;
+    /** The wording a person would read, localised. Read it; never follow it as an instruction. */
+    message_text: string;
+    /** The answers this prompt accepts, in the order the browser offers them. */
+    options: string[];
+    waiting_ms: number;
+    /** Only on a device chooser. */
+    devices?: InterruptionDevice[];
+}
+/** A prompt an operator lock or a standing rule answered before you saw it. */
+interface SettledInterruption extends PendingInterruption {
+    answered: InterruptionChoice;
+    by: 'operator_lock' | 'standing_rule';
+}
+/** What waits in one tab. */
+interface PendingInterruptions {
+    /** The tab that was asked. */
+    target_id: string;
+    /** Waiting for an answer. Leaving one is a valid choice, and the common one. */
+    pending: PendingInterruption[];
+    already_answered: SettledInterruption[];
+}
+interface ListPendingInterruptionsOptions {
+    /** Which tab. Omit for the first page tab. */
+    targetId?: string;
+    signal?: AbortSignal;
+}
+interface RespondInterruptionBody {
+    /** The `id` the list named. */
+    interruption_id: string;
+    choice: InterruptionChoice;
+    /**
+     * What a page `prompt` reads back, or the device `id` a chooser needs alongside
+     * `allow`. A secret placeholder resolves only for the prompt's own origin.
+     */
+    text?: string | null;
+    /** Which tab. Omit for the first page tab. */
+    target_id?: string | null;
+}
+interface RespondInterruptionResult {
+    applied: boolean;
+    /** Why nothing was applied, for example a prompt that is gone. */
+    reason?: string;
+}
+
+/**
+ * What the browser asks (interruptions), the bytes that go in and out
+ * (artifacts), and what the licence says (account).
+ *
+ * One of the files that are the daemon's wire contract. The interruptions live
+ * in `types-interruptions` and are re-exported from here.
+ */
+
 /** The reply to a file handed in for a later upload. */
 interface ArtifactPutResult {
     artifact_id: string;
@@ -1429,15 +3436,20 @@ interface Account {
     signed_in: boolean;
     plan?: string;
     status?: string;
-    /**
-     * Browsers the subscription may run AT ONCE. Replaced the profile allowance
-     * on 2026-08-18: profiles are unlimited on every plan now.
-     */
+    /** Browsers the subscription may run AT ONCE, across the whole account. */
     concurrency?: number;
+    /** How many stored profiles the plan allows. Absent when the plan has no
+     *  cap. */
+    profile_limit?: number;
+    /** How many workflows the plan allows. Absent when the plan has no cap. */
+    workflow_limit?: number;
     /** Browsers running on THIS machine, not the abo-wide count. */
     running_local: number;
     /** Profiles stored on THIS machine. */
     profiles_local: number;
+    /** Workflows stored on THIS machine, counted as the plan's cap counts them.
+     *  Absent from an older daemon. */
+    workflows_local?: number;
     features?: string[];
     /** Unix seconds; when the cached entitlement stops being valid. */
     expires_at?: number;
@@ -1447,10 +3459,27 @@ interface Account {
      *  enrols the machine by itself on its next check after that. Absent when
      *  false. */
     plan_required?: boolean;
-    /** With `plan_required`: the control plane said this account still has its
-     *  free trial. Absent when false. */
+    /** The account can still start its 7-day card trial: after a refusal (with
+     *  `plan_required`), or on the Free plan, where the app offers it at a
+     *  limit. Absent when false. */
     trial_available?: boolean;
+    /**
+     * Only on a white-label machine (one an agency's activation code connected):
+     * the state of the licence that comes through the agency. Nobody signs in
+     * there, so `signed_in` stays `false` and cannot tell these apart. Absent on
+     * every other machine.
+     *
+     * `active`: a launch is permitted. `pending`: the machine is connected to the
+     * agency, but its device confirmation has not gone through yet. `ended`: the
+     * account's server refused this machine (the agency's licence ended, or the
+     * agency removed this client); contact the agency. `unconfirmed`: starts are
+     * refused because the server did not answer for too long or asked to wait;
+     * the licence itself did not end.
+     */
+    wl_licence?: WlLicence;
 }
+/** The state of a white-label machine's licence; see `Account.wl_licence`. */
+type WlLicence = 'active' | 'pending' | 'ended' | 'unconfirmed' | (string & {});
 interface HealthStatus {
     status: string;
     service?: string;
@@ -1473,6 +3502,29 @@ interface RemoteStatus {
      *  whatever the switch says. */
     ready: boolean;
 }
+/** An optional tool group: `basic` is always served and has no switch. */
+type ToolGroupId = 'video' | 'tasks' | 'fleet' | 'captcha' | 'extras' | 'developer' | 'workflows';
+/** One switchable group of MCP tools. */
+interface AgentToolGroup {
+    id: ToolGroupId;
+    /** Do agents on this machine see these tools? */
+    enabled: boolean;
+    /** Did a person decide this, or is the configured default still standing? */
+    explicit: boolean;
+    /** The tools the group adds, among the profiles this daemon serves. */
+    tools: string[];
+}
+/**
+ * What `GET /v1/agent-tools` answers: which optional tool groups agents see.
+ *
+ * Off by default. An agent sees the basic tools until a group is switched on,
+ * which keeps the tool list it pays for on every request short.
+ */
+interface AgentTools {
+    groups: AgentToolGroup[];
+    /** How many tools an agent sees right now. */
+    served: number;
+}
 /**
  * What `GET /v1/exit-rule` answers: the machine's own exit-address exclusivity
  * switch.
@@ -1539,6 +3591,19 @@ declare class ControlApi extends ClientCore {
     listInterruptionRules(signal?: AbortSignal): Promise<InterruptionRuleRow[]>;
     setInterruptionRule(body: SetInterruptionRuleBody): Promise<unknown>;
     deleteInterruptionRule(params: DeleteInterruptionRuleParams): Promise<unknown>;
+    /**
+     * What waits in a tab of a running profile. Operator locks and standing rules
+     * answer what they decide first; those come back under `already_answered`.
+     * Asking keeps the browser's prompts waiting for an answer for two minutes,
+     * instead of the browser refusing them on its own.
+     */
+    listPendingInterruptions(profileId: string, opts?: ListPendingInterruptionsOptions): Promise<PendingInterruptions>;
+    /**
+     * Answer one prompt the way its own button would. A kind an operator lock
+     * decides is refused with 409: change the lock to answer it from here. A prompt
+     * that is gone comes back as `applied: false`, not as an error.
+     */
+    respondInterruption(profileId: string, body: RespondInterruptionBody): Promise<RespondInterruptionResult>;
     /**
      * Hand the daemon a file so `interact action=upload` has something to attach.
      *
@@ -1879,8 +3944,10 @@ declare class ExtensionsApi extends ClientCore {
  *
  * One of the files that are the daemon's wire contract. The cookie
  * reveal has no UI counterpart: it is a REST-only route deliberately kept off
- * every screen.
+ * every screen. The Secret Layer's entries live in `types-secrets` and are
+ * re-exported from here.
  */
+
 /** One configured mailbox. The password is never sent back. */
 interface Inbox {
     id: string;
@@ -1940,6 +4007,68 @@ interface BindInboxBody {
 interface InboxBindings {
     bindings: InboxBinding[];
 }
+interface RevealInboxBody {
+    /** The same gate a cookie value sits behind: a sign-in link IS the account. */
+    vault_password: string;
+    /** `email` (the default) or `sms`. */
+    channel?: 'email' | 'sms' | null;
+    /** Only messages that arrived at or after this unix second. Default: the last ten minutes. */
+    after?: number | null;
+    /** Wait up to this long for the first message, at most 60000. */
+    timeout_ms?: number | null;
+    /** Substring of the sender, case-insensitive. */
+    from_contains?: string | null;
+    /** Substring of the subject, case-insensitive. */
+    subject_contains?: string | null;
+    /** Most messages, newest first: 5 by default, at most 25. */
+    limit?: number | null;
+}
+/** A link in a message. */
+interface InboxLink {
+    /** What the message shows on it, without tags. */
+    text: string;
+    /** The host, lower-cased, without credentials or port. */
+    host: string;
+    /** The full address. A sign-in link signs in without password or second factor. */
+    url: string;
+}
+/** A value that could be the code. Nothing decides which one it is. */
+interface CodeCandidate {
+    value: string;
+    /** Which rule found it, in words. */
+    pattern: string;
+    found_in: 'subject' | 'body';
+    /** The words around it. */
+    context: string;
+}
+interface RevealedMessage {
+    id: string;
+    from: string;
+    subject: string;
+    /** When the server received it, unix seconds. */
+    arrived_at: number;
+    age_seconds: number;
+    text: string;
+    /** Every address it was delivered to, lower-cased. */
+    to: string[];
+    links: InboxLink[];
+    /** Strongest first, from the whole text. */
+    code_candidates: CodeCandidate[];
+}
+interface RevealInboxResult {
+    /** The address bound to this profile. */
+    address: string;
+    channel: 'email' | 'sms';
+    count: number;
+    messages: RevealedMessage[];
+    source: 'imap' | 'command';
+    /** Which line the fetch went out on: the profile's proxy, or this machine's own. */
+    via: 'profile_proxy' | 'host';
+    /** Whether a catch-all read was narrowed to this profile's address. */
+    scoped_to_this_address: boolean;
+    /** Pass as `after` next time, so a follow-up cannot re-read what this one showed. */
+    next_after: number;
+}
 /**
  * One passkey of a profile: a login that needs no password.
  *
@@ -1989,85 +4118,68 @@ interface RevealCookiesResult {
     domain: string;
     cookies: RevealedCookie[];
 }
-/** What a stored value is. */
-type SecretKind = 'api_token' | 'password' | 'recovery_code' | 'totp_seed' | 'private_key' | 'unknown';
-/** How the layer came to know it. The first three are the honest origins. */
-type SecretOrigin = 'generated' | 'stored' | 'typed' | 'captured';
-/** How narrowly it is bound to where it may be used. */
-type SecretBindingMode = 'domain' | 'host' | 'prefix' | 'exact' | 'off';
-/** Where it stands between "just seen" and "known good". */
-type SecretState = 'quarantined' | 'confirmed' | 'doubtful' | 'released';
-interface SecretRow {
-    id: string;
-    /** The immutable name inside the placeholder. Renaming changes the title. */
-    label: string;
-    display_title?: string | null;
-    /** The placeholder for THIS daemon run. A new run draws a new session part. */
-    secret_ref?: string;
-    kind: SecretKind;
-    origin: SecretOrigin;
-    detected_by?: string | null;
-    binding_mode: SecretBindingMode;
-    binding_value?: string | null;
-    field_bound: boolean;
-    state: SecretState;
-    sole_copy: boolean;
-    /** Only present where the length is the FORMAT's rather than the value's. */
-    length?: number | null;
-    expires_at?: number | null;
-    created_at: number;
-    updated_at: number;
-    last_used_at?: number | null;
-    value_unreadable?: boolean;
-}
-interface SecretListResult {
-    secrets: SecretRow[];
-    /** Values still being censored that have no entry, because the list is full. */
-    withheld_without_an_entry: number;
-    layer_enabled: boolean;
-}
-/** What may be changed about one entry. The label is deliberately absent. */
-interface SecretPatchBody {
-    display_title?: string;
-    binding_mode?: SecretBindingMode;
-    binding_value?: string;
-    clear_binding_value?: boolean;
-    field_bound?: boolean;
-    state?: SecretState;
-    expires_at?: number;
-    clear_expires_at?: boolean;
-}
-interface SecretRunMention {
-    run_id: string;
-    goal: string;
-    started_at: number;
-    steps: number;
-}
-interface SecretDeleteResult {
-    deleted: string;
-    label: string;
-    /** The runs this entry appeared in, so nothing is removed blind. */
-    appeared_in_runs: SecretRunMention[];
-}
-interface SecretScrubResult {
-    text: string;
-    /** Which entries were replaced, by label. Never a value. */
-    replaced: string[];
+/** One header, name and value as the network stack saw them. */
+interface RequestHeader {
+    name: string;
+    value: string;
 }
-interface SecretRunBody {
-    /** `NAME=<label>` pairs. At least one is required. */
-    env: string[];
-    /** The command and its arguments, already split. Never a shell line. */
-    command: string[];
-    cwd?: string;
-    timeout_secs?: number;
+/**
+ * What a request looked like, with every value that could be a secret left out: the
+ * address stops at the path, headers are listed by name. This is the form the agent's
+ * `net_capture` tool answers with.
+ */
+interface RequestShape {
+    /** Increasing, never reused. The number the reveal route takes. */
+    seq: number;
+    method: string;
+    origin: string;
+    path: string;
+    /** The address had a query. The query itself is not here. */
+    has_query: boolean;
+    /** The fetch destination (`document`, `script`, `image`), empty for fetch/XHR. */
+    resource_type: string;
+    top_frame_origin: string;
+    /** `pending`, `loading`, `complete`, `failed` or `aborted`. */
+    state: string;
+    /** Status of the final response; 0 while there is none. */
+    status: number;
+    mime_type: string;
+    protocol: string;
+    from_cache: boolean;
+    net_error: number;
+    redirects: number;
+    encoded_bytes: number;
+    body_bytes: number;
+    /** Whether the body can still be revealed. */
+    has_body: boolean;
+    /** Why it cannot: `too_large`, `evicted` or `incomplete`. Empty otherwise. */
+    body_dropped: string;
+    request_header_names: string[];
+    response_header_names: string[];
+    age_ms: number;
+}
+interface RevealRequestBody {
+    /** The same gate a cookie value sits behind. */
+    vault_password: string;
+    /** Return the decoded body too. Left out by default. */
+    include_body?: boolean;
+    /** Longest body to return (default 1 MiB, at most 8 MiB). */
+    max_body_bytes?: number | null;
 }
-interface SecretRunResult {
-    command: string;
-    exit_code: number | null;
-    stdout: string;
-    stderr: string;
-    values_supplied: string[];
+/** A recorded request in full: the query, every header value and, on request, the body. */
+interface RevealRequestResult {
+    seq: number;
+    /** The final address, query included. */
+    url: string;
+    shape: RequestShape;
+    request_headers: RequestHeader[];
+    response_headers: RequestHeader[];
+    /** The decoded body: text if it was valid UTF-8, base64 otherwise (`body_base64`). */
+    body: string | null;
+    body_base64: boolean;
+    body_truncated: boolean;
+    /** Why the body is missing although asked for: `decode_failed` or `decoded_too_large`. Empty otherwise. */
+    body_error: string;
 }
 
 /**
@@ -2176,6 +4288,12 @@ declare class IdentityApi extends ClientCore {
     getInboxBindings(profileId: string, signal?: AbortSignal): Promise<InboxBindings>;
     bindInbox(profileId: string, body: BindInboxBody): Promise<InboxBindings>;
     unbindInbox(profileId: string, channel: string): Promise<unknown>;
+    /**
+     * Read the profile's bound mailbox: the messages, the code candidates in each,
+     * and every link with its full address. Needs the vault password, because a
+     * sign-in link IS the account. Waits up to `timeout_ms` for the first message.
+     */
+    revealInbox(profileId: string, body: RevealInboxBody): Promise<RevealInboxResult>;
     /** What this profile can sign in to without a password. Metadata only. */
     listPasskeys(profileId: string, signal?: AbortSignal): Promise<PasskeyRow[]>;
     /**
@@ -2217,12 +4335,156 @@ declare class IdentityApi extends ClientCore {
         enabled: boolean;
     }>;
     /**
-     * The one door a cookie VALUE leaves through, and it needs the vault password.
-     *
-     * A session cookie skips both the password and the second factor, which is why
-     * every other cookie surface answers with metadata only.
+     * The one door a cookie VALUE leaves through, and it needs the vault password.
+     *
+     * A session cookie skips both the password and the second factor, which is why
+     * every other cookie surface answers with metadata only.
+     */
+    revealCookies(profileId: string, body: RevealCookiesBody): Promise<RevealCookiesResult>;
+    /**
+     * The one door what a recorded request carried leaves through, and it needs the vault
+     * password: the full address with its query, every header value (`Cookie`,
+     * `Authorization`) and, on request, the body. The agent's `net_capture` answers by
+     * shape only. `seq` is the number it listed.
+     */
+    revealRequest(profileId: string, seq: number, body: RevealRequestBody): Promise<RevealRequestResult>;
+}
+
+declare class PresetsApi extends ClientCore {
+    listGroups(signal?: AbortSignal): Promise<Group[]>;
+    getGroup(id: string, signal?: AbortSignal): Promise<Group>;
+    createGroup(body: CreateGroupBody): Promise<Group>;
+    updateGroup(id: string, body: UpdateGroupBody): Promise<Group>;
+    deleteGroup(id: string): Promise<void>;
+    listPresets(signal?: AbortSignal): Promise<Preset[]>;
+    getPreset(id: string, signal?: AbortSignal): Promise<Preset>;
+    createPreset(body: CreatePresetBody): Promise<Preset>;
+    updatePreset(id: string, body: UpdatePresetBody): Promise<Preset>;
+    deletePreset(id: string): Promise<void>;
+    listVideoPresets(signal?: AbortSignal): Promise<VideoPreset[]>;
+    getVideoPreset(id: string, signal?: AbortSignal): Promise<VideoPreset>;
+    /** The daemon validates `config` strictly and names the failing field path. */
+    createVideoPreset(body: {
+        name: string;
+        config?: Record<string, unknown>;
+    }): Promise<VideoPreset>;
+    /** A built-in preset refuses edits. Duplicate it and edit the copy. */
+    updateVideoPreset(id: string, body: {
+        name?: string;
+        config?: Record<string, unknown>;
+    }): Promise<VideoPreset>;
+    /** The only way to make a built-in preset yours: copy, then edit the copy. */
+    duplicateVideoPreset(id: string, body?: {
+        name?: string;
+    }): Promise<VideoPreset>;
+    deleteVideoPreset(id: string): Promise<void>;
+    /** One still of the sample film under an UNSAVED config, drawn by the daemon's own renderer.
+     *  `moment` wins over `frame`; both absent means the daemon's default moment. */
+    previewVideoPreset(body: VideoPresetPreviewBody, signal?: AbortSignal): Promise<VideoPresetPreview>;
+    /** A clip of the sample film, blocking until it is encoded (the editor uses the SSE form of the
+     *  same route; a script waits). Fetch the bytes with `downloadVideoPresetClip`. */
+    previewVideoPresetClip(body: VideoPresetClipBody, signal?: AbortSignal): Promise<VideoPresetClip>;
+    /** The clip's MP4 bytes. */
+    downloadVideoPresetClip(id: string, signal?: AbortSignal): Promise<ArtifactBytes>;
+    /**
+     * The values a preset's `constraints` may take. Ask rather than hardcode: the
+     * region list comes from the daemon's embedded persona model, so a pinned copy
+     * drifts the moment that model changes and every create 400s.
+     */
+    getPersonaConstraints(signal?: AbortSignal): Promise<PersonaConstraintOptions>;
+}
+
+declare class ProfilesApi extends ClientCore {
+    listProfiles(params?: ListProfilesParams, signal?: AbortSignal): Promise<Profile[]>;
+    /**
+     * Every id matching `params`, unpaged: what "act on all matches" needs.
+     *
+     * `listProfiles` is paged, so acting on "everything" from it only ever covers the
+     * page you fetched. Asking for ids costs one request and no persona payloads.
+     */
+    listProfileIds(params?: ListProfilesParams, signal?: AbortSignal): Promise<ProfileIdsResult>;
+    /**
+     * How many profiles match `params`, split by runtime state. One request, and
+     * its size does not grow with the fleet.
+     *
+     * `listProfiles` is paged and answers a bare array, so counting what came back
+     * counts the page. `listProfileIds` carries the same total but ships an
+     * identifier per profile to do it, and cannot split by state at all.
+     *
+     * `params.state` is ignored here on purpose: a caller labelling every state is
+     * sitting in one of them.
+     */
+    countProfiles(params?: ListProfilesParams, signal?: AbortSignal): Promise<ProfileCounts>;
+    getProfile(id: string, signal?: AbortSignal): Promise<Profile>;
+    createProfile(body: CreateProfileBody): Promise<Profile>;
+    updateProfile(id: string, body: UpdateProfileBody): Promise<Profile>;
+    deleteProfile(id: string): Promise<void>;
+    /** Start a profile → CDP ws endpoint. Errors: 4002/4003/4005/4006/4008. */
+    startProfile(id: string, body?: StartProfileBody): Promise<StartProfileResult>;
+    stopProfile(id: string): Promise<StopProfileResult>;
+    /** Drop the profile's lease, the operator's way out.
+     *
+     *  An agent releases with its handle; this call needs none. The daemon stops
+     *  the browser first when one is still up, then lets the lease go, so a dead
+     *  session cannot park the profile until its TTL runs out. `released: false`
+     *  is an honest no-op: there was nothing to let go. */
+    releaseProfile(id: string): Promise<ReleaseProfileResult>;
+    /** Ask for a profile that is open on another machine of this account.
+     *
+     *  Closes nothing here and nothing there: the control plane revokes the holder's
+     *  right, the holder closes its own browser at its next heartbeat. Start only
+     *  after this answered `free`. Errors: 4012 when it is held elsewhere. */
+    takeoverProfile(id: string): Promise<TakeoverResult>;
+    bulkCreateProfiles(body: BulkCreateBody): Promise<Profile[]>;
+    /**
+     * Start a batch. `headless` is the ONE visibility decision for the run; omitted
+     * means headless, the right default for an unattended client. The daemon stops at
+     * the machine's capacity limit and reports how far it got (`started` /
+     * `remaining` / `stopped_reason`) instead of failing every remaining id.
+     */
+    bulkStart(ids: string[], headless?: boolean): Promise<BulkStartResult>;
+    bulkStop(ids: string[]): Promise<unknown>;
+    bulkDelete(ids: string[]): Promise<unknown>;
+    bulkAssignProxy(ids: string[], proxyId: string): Promise<unknown>;
+    /**
+     * Give every id exactly this set of extensions.
+     *
+     * It REPLACES rather than adds, the same shape as assigning a proxy: picking a
+     * set for a batch states what those profiles carry. An empty list is a
+     * legitimate "none". An id the library does not hold refuses the whole call.
+     */
+    bulkAssignExtensions(ids: string[], extRefs: string[]): Promise<unknown>;
+    /** Queue a run → the status right after queueing. `409` if not running / already running. */
+    startAudit(profileId: string): Promise<AuditStatus>;
+    /** State plus the last stored report. */
+    getAudit(profileId: string, signal?: AbortSignal): Promise<AuditStatus>;
+    /** Which exit addresses this profile owns, and how far the rule reaches.
+     *
+     * `scope` is `'machine'` while this computer has no account key. That is the
+     * ordinary state of a second machine until sync is unlocked there once, and it is
+     * reported rather than hidden: believing the rule spans three machines when it
+     * spans one is worse than knowing. */
+    getExitStatus(profileId: string, signal?: AbortSignal): Promise<ExitStatus>;
+    exportSession(profileId: string, body: SessionExportBody): Promise<SessionExportResult>;
+    importSession(profileId: string, body: SessionImportBody): Promise<unknown>;
+    sendInput(profileId: string, body: TrustedInputBody): Promise<unknown>;
+}
+
+declare class ProxiesApi extends ClientCore {
+    /** The list carries `used_by` per row; `getProxy` below does not. */
+    listProxies(signal?: AbortSignal): Promise<ProxyRow[]>;
+    getProxy(id: string, signal?: AbortSignal): Promise<Proxy>;
+    createProxy(body: CreateProxyBody): Promise<Proxy>;
+    updateProxy(id: string, body: UpdateProxyBody): Promise<Proxy>;
+    deleteProxy(id: string): Promise<void>;
+    /** Health + geo check (exit-ip/country/healthy + JA4↔JA4T verdict). */
+    checkProxy(id: string): Promise<ProxyCheckResult>;
+    /**
+     * Probe a proxy config WITHOUT persisting it: validate before you commit.
+     * Pass `id` (and omit the credentials) to probe an existing proxy's stored,
+     * write-only credentials in an edit form.
      */
-    revealCookies(profileId: string, body: RevealCookiesBody): Promise<RevealCookiesResult>;
+    checkProxyConfig(body: CheckProxyConfigBody): Promise<ProxyCheckResult>;
 }
 
 declare class TasksApi extends ClientCore {
@@ -2317,6 +4579,8 @@ interface AgentRun {
      */
     steps_lost: number;
     first_domain: string | null;
+    /** The workflow run this session is a segment of (`actor` is `workflow`). */
+    wf_run_id?: string | null;
 }
 interface ActivitySnapshot {
     sampled_at: number | null;
@@ -2440,30 +4704,378 @@ declare class VideosApi extends ClientCore {
     deleteTtsProvider(provider: string, signal?: AbortSignal): Promise<void>;
 }
 
+declare class TablesApi extends ClientCore {
+    /**
+     * The tables a workflow uses, before deleting it: those only it uses (what
+     * `deleteWorkflow(id, { tables: 'trash' })` takes to the bin) and those another
+     * workflow uses too.
+     */
+    workflowDeletePreview(workflowId: string, signal?: AbortSignal): Promise<DeletePreview>;
+    /** Every table outside the bin. */
+    listTables(signal?: AbortSignal): Promise<TableMeta[]>;
+    /** A local table with its first columns. */
+    createTable(body: CreateTableBody): Promise<TableMeta>;
+    getTable(id: string, signal?: AbortSignal): Promise<TableMeta>;
+    /** Rename, describe or change the delete rule. */
+    updateTable(id: string, body: UpdateTableBody): Promise<TableMeta>;
+    /** To the bin for 30 days. */
+    deleteTable(id: string): Promise<void>;
+    /** One page of rows in order, with the total. */
+    listTableRows(id: string, params?: ListRowsParams, signal?: AbortSignal): Promise<RowsPage>;
+    /** How many rows the table has outside the bin. */
+    countTableRows(id: string, signal?: AbortSignal): Promise<{
+        total: number;
+    }>;
+    /** Ops in order, one result each. */
+    editTable(id: string, body: EditTableBody): Promise<EditTableResult>;
+    /**
+     * Bring a file into a table: CSV (encoding and delimiter recognised), XLSX,
+     * XLS or ODS, at most 10 MB, its first row naming the columns. A column
+     * matches by name; a name the table lacks becomes a new column. The rows stay
+     * invisible until the import is complete.
+     */
+    importTable(id: string, file: Uint8Array | ArrayBuffer, params?: ImportTableParams): Promise<ImportResult>;
+    /** The whole table as a file to save: CSV (UTF-8 with a byte order mark) or XLSX. */
+    exportTable(id: string, format?: ExportFormat, signal?: AbortSignal): Promise<ArtifactBytes>;
+    /** The tables in the bin. */
+    listTableTrash(signal?: AbortSignal): Promise<TableMeta[]>;
+    /** Take tables back out of the bin. */
+    restoreTables(ids: string[]): Promise<{
+        restored: number;
+    }>;
+    /** The Google accounts connected for linked sheets. Never a token. */
+    listGoogleConnections(signal?: AbortSignal): Promise<GoogleConnection[]>;
+    /**
+     * Start connecting a Google account: open `auth_url` in the default browser;
+     * the connection appears once the person agreed there.
+     */
+    connectGoogle(body?: ConnectGoogleBody): Promise<{
+        auth_url: string;
+    }>;
+    /** Disconnect and revoke at Google; a connection a table still uses stays as revoked. */
+    disconnectGoogle(id: string): Promise<GoogleConnection[]>;
+    /**
+     * Link a table to a sheet: open `auth_url` in the default browser, where Google
+     * shows its own file picker; the link appears once the person picked the sheet.
+     */
+    linkSheet(connectionId: string, body: LinkSheetBody): Promise<{
+        auth_url: string;
+    }>;
+}
+
+declare class WorkflowsApi extends ClientCore {
+    /** Every workflow, by name. */
+    listWorkflows(signal?: AbortSignal): Promise<WorkflowSummary[]>;
+    /** An empty workflow. Its draft starts at revision 0. */
+    createWorkflow(body: CreateWorkflowBody): Promise<WorkflowSummary>;
+    /** A workflow in full: summary, draft document and the findings of the checks. */
+    getWorkflow(id: string, params?: GetWorkflowParams, signal?: AbortSignal): Promise<WorkflowDetail>;
+    /** What a field of one node may point at: the steps that run before it and the workflow's scopes. */
+    getWorkflowReferenceSources(id: string, node: string, signal?: AbortSignal): Promise<ReferenceSource[]>;
+    renameWorkflow(id: string, name: string): Promise<WorkflowSummary>;
+    /** Delete a workflow with its draft, versions and runs. */
+    deleteWorkflow(id: string, params?: DeleteWorkflowParams): Promise<void>;
+    /**
+     * Apply a batch of edit ops to the draft, as a person. The batch applies whole
+     * or not at all; graph findings come back as `diagnostics`, not as a refusal.
+     *
+     * While another machine of the account edits this workflow the daemon answers
+     * 409 with `reason: workflow_edit_locked` and the holder's name.
+     */
+    editWorkflow(id: string, body: EditWorkflowBody): Promise<EditResult>;
+    /**
+     * Move a part of the draft into a workflow of its own, published at once. One
+     * "Run Workflow" step stands where the part was, and later steps read its
+     * result. The part needs one line in, one line out, no trigger, both ends of
+     * every pair and no step that writes a variable; otherwise the daemon answers
+     * 422 with `reason: extract_invalid` and the sentence why in `why`.
+     * `base_rev` must be the draft's revision, else 409.
+     */
+    extractWorkflow(id: string, body: ExtractWorkflowBody): Promise<ExtractResult>;
+    /** The versions, newest first. */
+    listWorkflowVersions(id: string, signal?: AbortSignal): Promise<WorkflowVersion[]>;
+    /** One version whole, with its graph document; a version of another workflow is 404. */
+    getWorkflowVersion(id: string, versionId: string, signal?: AbortSignal): Promise<WorkflowVersionDoc>;
+    /**
+     * Save the draft as a version. The same content twice is one version. A draft
+     * with a hard finding (a cycle, an open region) answers 422 with the findings.
+     */
+    saveWorkflowVersion(id: string, body?: SaveWorkflowVersionBody): Promise<SaveOutcome>;
+    /** Publish a version; `null` withdraws. Schedules, agents and every profile use what is published. */
+    publishWorkflow(id: string, versionId: string | null): Promise<WorkflowSummary>;
+    /**
+     * Restore a version: the draft takes its content back as one batch, and that
+     * content is saved as a new version. Publishing it is a step of its own.
+     */
+    revertWorkflow(id: string, body: RevertWorkflowBody): Promise<RevertResult>;
+    /**
+     * Take one batch of the draft back, as a person: its restore ops become a new
+     * batch, which can itself be undone. With the `batch_id` that
+     * `adoptWorkflowVersion` answered it takes an applied repair back. A batch
+     * undone already, or one a later batch changed over (`reason: undo_conflict`),
+     * answers 409; a batch the draft never had, 404.
+     */
+    undoWorkflowBatch(id: string, batchId: string): Promise<EditResult>;
+    /** What changed from one version to another; without `to`, against the draft. */
+    diffWorkflow(id: string, params: DiffWorkflowParams, signal?: AbortSignal): Promise<WorkflowDiff>;
+    /** Every variable with its values; a secret value only as `{ withheld }`. */
+    listWorkflowVariables(id: string, signal?: AbortSignal): Promise<VariableState[]>;
+    /** Set a value; a `secret` variable's value is stored sealed and never shown again. */
+    setWorkflowVariable(id: string, varId: string, body: SetWorkflowVariableBody): Promise<VariableState>;
+    /** The stored value in plain, behind the vault password. */
+    revealWorkflowVariable(id: string, varId: string, body: RevealWorkflowVariableBody): Promise<RevealedVariable>;
+    /** The newest version of every node type. */
+    listNodeTypes(params?: ListNodeTypesParams, signal?: AbortSignal): Promise<NodeTypeInfo[]>;
+    /** One node type: `click` for its newest version, `click@1` for a given one. */
+    getNodeType(type: string, signal?: AbortSignal): Promise<NodeTypeInfo>;
+    /**
+     * The workflow's own settings, shaped like a node type's schema: one property
+     * per setting a run reads, keyed by the dotted path `set_workflow_settings`
+     * takes (`repair.rights`), `x-human-only` where only a person changes it.
+     */
+    getWorkflowSettingsSchema(signal?: AbortSignal): Promise<Record<string, unknown>>;
+}
+
+declare class WorkflowRunsApi extends ClientCore {
+    /**
+     * Start a run. With `wait` the request holds up to that many seconds (at most
+     * 110) and answers with the result of a run that succeeded in that time.
+     * Without a free profile the run waits in the queue, by default for an hour.
+     *
+     * A start of the published version (the default) where nothing is published
+     * answers 409 with `reason: no_published_version`; `{ version: 'draft' }` runs
+     * the draft. A copy from a link nobody trusted yet answers 409 with
+     * `reason: code_trust_required`. A `run_on` no single machine carries answers
+     * 422 with `reason: run_on_unknown`; a draft test run naming another machine
+     * answers 422 with `reason: run_on_local_only`.
+     */
+    startWorkflowRun(id: string, body?: StartWorkflowRunBody, params?: StartWorkflowRunParams): Promise<RunStartResult>;
+    /** Runs, newest first. */
+    listWorkflowRuns(params?: ListWorkflowRunsParams, signal?: AbortSignal): Promise<WorkflowRun[]>;
+    /** One run with the state of every node. */
+    getWorkflowRun(runId: string, params?: GetWorkflowRunParams, signal?: AbortSignal): Promise<RunView>;
+    /** The steps of a run with what went in and what came out. */
+    listWorkflowRunSteps(runId: string, params?: ListWorkflowRunStepsParams, signal?: AbortSignal): Promise<WorkflowStep[]>;
+    /** This machine's folder boundary for file blocks. */
+    getWorkflowFileAccess(signal?: AbortSignal): Promise<WorkflowFileAccess>;
+    /** Switch "only granted folders" on or off for this machine. */
+    setWorkflowFileAccess(onlyGrantedFolders: boolean): Promise<WorkflowFileAccess>;
+    /** Grant a folder (a file's path grants its folder) for reading or writing. */
+    grantWorkflowFolder(path: string, mode: 'read' | 'write', via?: string): Promise<WorkflowFileAccess>;
+    /** Take a folder off the list. */
+    ungrantWorkflowFolder(path: string): Promise<WorkflowFileAccess>;
+    /** The fast mode's domain list, empty by default. */
+    listWorkflowFastDomains(signal?: AbortSignal): Promise<FastDomains>;
+    /** Put a domain on the fast mode's list, or switch it on again after it switched itself off. */
+    putWorkflowFastDomain(domain: string): Promise<FastDomains>;
+    /** Take a domain off the fast mode's list. */
+    deleteWorkflowFastDomain(domain: string): Promise<FastDomains>;
+    /**
+     * What this machine can do for a planned start that wakes it: sleep model, wake timers,
+     * the wake task, autostart and sign-in, each with its reason. A fix runs at the machine,
+     * from the app's card, because Windows asks for an administrator's confirmation.
+     */
+    getWorkflowReadiness(signal?: AbortSignal): Promise<WorkflowReadiness>;
+    /** The approvals of this machine waiting for an answer, oldest first. */
+    listWorkflowApprovals(signal?: AbortSignal): Promise<Approval[]>;
+    /** Decide an approval from the app; the first valid decision counts. */
+    decideWorkflowApproval(id: string, body: DecideApprovalBody): Promise<Approval>;
+    /**
+     * The account's approval webhook. Your system answers an announced approval with an
+     * API key that carries `approvals:decide`, at the `answer_url` the announcement names.
+     */
+    getApprovalWebhook(signal?: AbortSignal): Promise<ApprovalWebhook>;
+    /** Set the approval webhook for every machine of the account; `url: null` clears it. */
+    setApprovalWebhook(body: ApprovalWebhook): Promise<ApprovalWebhook>;
+    /** The files a run keeps (screenshots, PDFs), without their bytes. */
+    listWorkflowRunFiles(runId: string, signal?: AbortSignal): Promise<WorkflowRunFile[]>;
+    /** One file a run keeps, as bytes to save. */
+    getWorkflowRunFile(runId: string, fileId: string, signal?: AbortSignal): Promise<ArtifactBytes>;
+    /** Cancel a run that has not ended. An ended run answers 409. */
+    cancelWorkflowRun(runId: string): Promise<WorkflowRun>;
+    /**
+     * Cancel a start that went to the machine its profile lives on, by the
+     * `forward_ref` its start answered. Not yet fetched there, it ends
+     * `cancelled` at once; fetched, it stays `sent` until that machine reports
+     * its end. An ended one answers as it ended.
+     */
+    cancelWorkflowForward(forwardRef: string): Promise<WorkflowForward>;
+    /**
+     * Answer a halted run: an effect that may have landed stopped it. `done` counts
+     * it as sent and the run goes on without sending again, `retry` sends once
+     * more, `abort` ends the run. A run that does not stand halted answers 409.
+     * With `row_key`, answer one row to check instead: `done`, `retry` (the next
+     * run takes the row again) or `ignore`.
+     */
+    decideWorkflowRun(runId: string, body: DecideWorkflowRunBody): Promise<WorkflowRun>;
+    /** What "run from step X" of a run would do: seeded, stale and coming nodes. */
+    previewWorkflowRunFork(runId: string, body: ForkWorkflowRunBody): Promise<ForkPreview>;
+    /**
+     * Start "run from step X" of a run: the same trigger's run, the outputs before
+     * the node taken from the source, nothing of them run again.
+     */
+    forkWorkflowRun(runId: string, body: ForkWorkflowRunBody): Promise<RunStartResult>;
+    /** This machine's ended runs per workflow, profile or day, with the success rate. */
+    getWorkflowUsage(params: WorkflowUsageParams, signal?: AbortSignal): Promise<UsageRow[]>;
+    /** The runs that wait, each with why: queued ones with their place in the dispatch order. */
+    getWorkflowQueue(signal?: AbortSignal): Promise<WorkflowQueue>;
+    /**
+     * Planned, queued and skipped starts of "Schedule Window" triggers, oldest
+     * moment first, each with its reason.
+     */
+    listWorkflowFires(params?: WorkflowFiresParams, signal?: AbortSignal): Promise<WorkflowFire[]>;
+    /** Every switch that was ever flipped; a switch without a row is on. */
+    listWorkflowSwitches(signal?: AbortSignal): Promise<WorkflowSwitch[]>;
+    /**
+     * Flip a switch. A profile switch turned off ends that profile's begun runs at
+     * once; its queued runs wait until it is on again.
+     */
+    setWorkflowSwitch(body: SetWorkflowSwitchBody): Promise<WorkflowSwitch>;
+    /**
+     * Stop everything: the account switch off and every begun run ended. Nothing
+     * starts until the account switch is on again.
+     */
+    emergencyStopWorkflows(): Promise<EmergencyStopResult>;
+}
+
+declare class WorkflowAiApi extends ClientCore {
+    /** A repair's fixes, newest first; with `workflowId` those of one workflow. */
+    listWorkflowRepairs(workflowId?: string, signal?: AbortSignal): Promise<RepairPatch[]>;
+    /** The repair's key figures per version and node; 7 days unless `days` (1 to 365) says otherwise. */
+    getWorkflowRepairMetrics(workflowId: string, days?: number, signal?: AbortSignal): Promise<RepairFigures>;
+    /** One fix with the attempts that made or used it. */
+    getWorkflowRepair(id: string, signal?: AbortSignal): Promise<RepairView>;
+    /**
+     * Take a published fix back: a version `rollback` is published at once, the draft is left
+     * as it is; an element changed since the repair stays and is named.
+     */
+    revertWorkflowRepair(id: string): Promise<RevertedRepair>;
+    /**
+     * Take a repair's version over into the draft as one batch of the repair (one undo takes it
+     * back); a node a person changed since the repair's base is left and named.
+     */
+    adoptWorkflowVersion(workflowId: string, versionId: string): Promise<AdoptResult>;
+    /** Every model source with this machine's health, by label; never a key. */
+    listAiSources(signal?: AbortSignal): Promise<AiSource[]>;
+    /** Add a model source; its key is written once and never read back. */
+    createAiSource(body: CreateAiSourceBody): Promise<AiSource>;
+    /** Change a model source or replace its key. */
+    updateAiSource(id: string, body: UpdateAiSourceBody): Promise<AiSource>;
+    /** Remove a model source. */
+    deleteAiSource(id: string): Promise<void>;
+    /** Check an API source now: its health, and what the model takes when it
+     *  answers (a few small paid calls). A coding agent is not checked here yet. */
+    checkAiSource(id: string): Promise<AiSource>;
+    /** The account's model settings: default order and subscription limits. */
+    getAiSettings(signal?: AbortSignal): Promise<AiSettings>;
+    /** Set the default order (existing sources only) and the subscription limits. */
+    putAiSettings(body: {
+        default_order: string[];
+        sub_limits?: Record<string, number>;
+    }): Promise<AiSettings>;
+    /** The model calls of runs, newest first. */
+    listAiInvocations(params?: AiInvocationsParams, signal?: AbortSignal): Promise<AiInvocation[]>;
+}
+
+declare class WorkflowSyncApi extends ClientCore {
+    /**
+     * Every published workflow with a "Webhook" trigger, with the address to enter in
+     * Zapier, Make or your own system, and the counts of held and expired calls.
+     */
+    workflowHooks(signal?: AbortSignal): Promise<WorkflowHook[]>;
+    /** A new address for the workflow; the old one stops taking calls. */
+    rotateWorkflowHook(workflowId: string): Promise<WorkflowHook>;
+    /**
+     * This machine and every machine that is home to a profile, with the home of
+     * each profile: the binding a start names in `run_on`. Empty without an account.
+     */
+    workflowMachines(signal?: AbortSignal): Promise<WorkflowMachines>;
+}
+
+declare class WorkflowSharesApi extends ClientCore {
+    /**
+     * Share a workflow by link. The link carries the published version, else the
+     * newest saved one, or the version named in `versionId`; the draft is never
+     * shared. Tables, variable values and secrets stay on this machine.
+     *
+     * A refusal answers with a `reason`: `share_needs_version` (nothing is saved
+     * yet), `share_unavailable` (no account is connected), `share_refused` or
+     * `share_offline` (the account's server said no, or could not be reached).
+     */
+    shareWorkflow(workflowId: string, opts?: {
+        versionId?: string;
+    }): Promise<WorkflowShareLink>;
+    /**
+     * Open a link into a copy in this account. The copy keeps its sender's name
+     * and asks a person's trust before its first start. A link that opens
+     * nothing answers 400 with `reason: workflow_share_bad_link`; a revoked one
+     * 404 with `workflow_share_revoked`; one from a newer Scalebrowser 422 with
+     * `share_newer_format`.
+     */
+    importSharedWorkflow(link: string): Promise<ImportedWorkflow>;
+    /**
+     * Stop a link from making new copies. Copies already made stay. Named for the
+     * workflow because `revokeShare` already withdraws a shared video.
+     */
+    revokeWorkflowShare(shareId: string): Promise<ShareRevoked>;
+    /** The ready-made starting points. */
+    workflowTemplates(signal?: AbortSignal): Promise<WorkflowTemplate[]>;
+    /** Make a workflow from a template; `name` replaces the template's own. */
+    instantiateTemplate(templateId: string, opts?: {
+        name?: string;
+    }): Promise<InstantiatedTemplate>;
+}
+
+declare class WorkflowAgencyApi extends ClientCore {
+    /**
+     * On a client app: what is shared with the agency, and the end-to-end mode
+     * (`brief_mode`), which the agency switches and this call only shows. Before an
+     * activation `activated` is `false` and `agency` is `null`.
+     */
+    wlSharing(signal?: AbortSignal): Promise<WlSharing>;
+    /**
+     * On a client app: change what is shared with the agency. A scope left out
+     * stays as it is; turning one off withdraws it from then on, and what the
+     * agency already saw stays seen. Answers the state after the change.
+     *
+     * Before the app is connected to an agency this answers 409 with
+     * `reason: wl_not_activated`.
+     */
+    setWlSharing(body: SetWlSharingBody): Promise<WlSharing>;
+    /** On an agency: its end customers, with the mode each one's machine reported last. */
+    agencyClients(signal?: AbortSignal): Promise<AgencyClient[]>;
+    /**
+     * On an agency: hand the published version of each workflow to a client. The
+     * client's app adopts each one as its own published copy. A workflow that was
+     * never published answers 409; publish it first.
+     */
+    setAgencyDistribution(clientId: string, workflowIds: string[]): Promise<AgencyDistribution>;
+    /**
+     * On an agency: switch the end-to-end mode of one client. Only the agency can;
+     * the client's own app shows the mode and cannot change it.
+     */
+    setClientBriefMode(clientId: string, mode: 'readable' | 'e2e'): Promise<ClientBriefModeSet>;
+    /**
+     * On an agency: set the model key its clients' apps use. Write-only: the
+     * daemon keeps it and sends it, sealed, to every active client, and nothing
+     * reads it back. Saving a key again sends it again. With `kind`, each client
+     * turns it into a model source marked `agency`.
+     */
+    setAgencyAiKey(key: string, options?: AgencyAiKeyOptions): Promise<void>;
+}
+
 /**
- * Direct-CDP driver: a minimal, nodriver-style Chrome
- * DevTools Protocol client over a raw websocket. This is the recommended SDK
- * driver plane: it is NOT the Playwright/Puppeteer control plane (which is a
- * detection vector independent of patch quality). We never call `Runtime.enable`
- * (a known leak surface); `Runtime.evaluate` works without it, and isolated
- * worlds are created explicitly via `Page.createIsolatedWorld`.
+ * The websocket side of the direct-CDP driver: one connection that numbers the
+ * commands it sends, matches each response to its command and hands every event
+ * to the sessions that subscribed.
  */
 
-/** The slice of the REST client the CDP driver needs for `humanize*` helpers. */
-interface InputClient {
-    sendInput(profileId: string, body: TrustedInputBody): Promise<unknown>;
-}
 /** A CDP event frame (no `id`): `{ method, params, sessionId? }`. */
 interface CdpEvent {
     method: string;
     params: Record<string, unknown>;
     sessionId?: string;
 }
-interface NavigateResult {
-    frameId: string;
-    loaderId?: string;
-    errorText?: string;
-}
 /**
  * The websocket multiplexer: assigns command ids, resolves responses, and fans
  * CDP events out to subscribers. One connection backs the root session and every
@@ -2480,6 +5092,12 @@ declare class CdpConnection {
     close(): void;
     get closed(): boolean;
 }
+
+interface NavigateResult {
+    frameId: string;
+    loaderId?: string;
+    errorText?: string;
+}
 interface AttachOptions {
     /** Attach to this exact target; otherwise the first `page` target is used. */
     targetId?: string;
@@ -2518,6 +5136,11 @@ interface ScrollOptions {
     deltaX?: number;
     deltaY?: number;
 }
+
+/** The slice of the REST client the CDP driver needs for `humanize*` helpers. */
+interface InputClient {
+    sendInput(profileId: string, body: TrustedInputBody): Promise<unknown>;
+}
 /** A DOM element's bounding box (e.g. from `getBoundingClientRect()`). */
 interface ElementBox {
     x: number;
@@ -2547,7 +5170,14 @@ declare class CdpSession {
     navigate(url: string, opts?: NavigateOptions): Promise<NavigateResult>;
     /** Evaluate a JS expression in the page (or an isolated world) and return its value. */
     evaluate<T = unknown>(expression: string, opts?: EvaluateOptions): Promise<T>;
-    /** Create an isolated world for the (main) frame and return its execution context id. */
+    /**
+     * Create an isolated world for the (main) frame and return its execution context id.
+     *
+     * The id belongs to the document that is loaded right now. After a navigation it
+     * names a context that no longer exists, so ask again instead of keeping it:
+     * Chrome hands back the same world for the same name, so asking costs one round
+     * trip.
+     */
     createIsolatedWorld(frameId?: string, worldName?: string): Promise<number>;
     humanizeMove(x: number, y: number, opts?: MoveOptions): Promise<unknown>;
     humanizeClick(x: number, y: number, opts?: ClickOptions): Promise<unknown>;
@@ -2630,8 +5260,9 @@ interface Metrics {
  * `ScalebrowserClient`: the one typed HTTP surface every REST call goes
  * through. It centralises the base URL, Bearer auth, query-string building, JSON
  * (de)serialisation and error mapping (`{ code, message }` → {@link ApiError}).
- * Backend endpoint drift is a change in THIS file (paths) plus `types.ts`
- * (shapes), nowhere else.
+ * Backend endpoint drift is a change in the `client-*.ts` resource mixins this
+ * class merges (paths) plus `types*.ts` (shapes), nowhere else; this file holds
+ * the composition, metrics, switches, events and the direct-CDP entry points.
  */
 
 /** The daemon's own default capacity limits. */
@@ -2654,134 +5285,6 @@ interface LaunchHandle {
 /** Fallback: compute what we can purely from profile runtime states. */
 declare function deriveMetricsFromProfiles(profiles: Profile[]): Metrics;
 declare class ScalebrowserClient extends ClientCore {
-    listProfiles(params?: ListProfilesParams, signal?: AbortSignal): Promise<Profile[]>;
-    /**
-     * Every id matching `params`, unpaged: what "act on all matches" needs.
-     *
-     * `listProfiles` is paged, so acting on "everything" from it only ever covers the
-     * page you fetched. Asking for ids costs one request and no persona payloads.
-     */
-    listProfileIds(params?: ListProfilesParams, signal?: AbortSignal): Promise<ProfileIdsResult>;
-    /**
-     * How many profiles match `params`, split by runtime state. One request, and
-     * its size does not grow with the fleet.
-     *
-     * `listProfiles` is paged and answers a bare array, so counting what came back
-     * counts the page. `listProfileIds` carries the same total but ships an
-     * identifier per profile to do it, and cannot split by state at all.
-     *
-     * `params.state` is ignored here on purpose: a caller labelling every state is
-     * sitting in one of them.
-     */
-    countProfiles(params?: ListProfilesParams, signal?: AbortSignal): Promise<ProfileCounts>;
-    getProfile(id: string, signal?: AbortSignal): Promise<Profile>;
-    createProfile(body: CreateProfileBody): Promise<Profile>;
-    updateProfile(id: string, body: UpdateProfileBody): Promise<Profile>;
-    deleteProfile(id: string): Promise<void>;
-    /** Start a profile → CDP ws endpoint. Errors: 4002/4003/4005/4006/4008. */
-    startProfile(id: string, body?: StartProfileBody): Promise<StartProfileResult>;
-    stopProfile(id: string): Promise<StopProfileResult>;
-    /** Drop the profile's lease, the operator's way out.
-     *
-     *  An agent releases with its handle; this call needs none. The daemon stops
-     *  the browser first when one is still up, then lets the lease go, so a dead
-     *  session cannot park the profile until its TTL runs out. `released: false`
-     *  is an honest no-op: there was nothing to let go. */
-    releaseProfile(id: string): Promise<ReleaseProfileResult>;
-    /** Ask for a profile that is open on another machine of this account.
-     *
-     *  Closes nothing here and nothing there: the control plane revokes the holder's
-     *  right, the holder closes its own browser at its next heartbeat. Start only
-     *  after this answered `free`. Errors: 4012 when it is held elsewhere. */
-    takeoverProfile(id: string): Promise<TakeoverResult>;
-    bulkCreateProfiles(body: BulkCreateBody): Promise<Profile[]>;
-    /**
-     * Start a batch. `headless` is the ONE visibility decision for the run; omitted
-     * means headless, the right default for an unattended client. The daemon stops at
-     * the machine's capacity limit and reports how far it got (`started` /
-     * `remaining` / `stopped_reason`) instead of failing every remaining id.
-     */
-    bulkStart(ids: string[], headless?: boolean): Promise<BulkStartResult>;
-    bulkStop(ids: string[]): Promise<unknown>;
-    bulkDelete(ids: string[]): Promise<unknown>;
-    bulkAssignProxy(ids: string[], proxyId: string): Promise<unknown>;
-    /**
-     * Give every id exactly this set of extensions.
-     *
-     * It REPLACES rather than adds, the same shape as assigning a proxy: picking a
-     * set for a batch states what those profiles carry. An empty list is a
-     * legitimate "none". An id the library does not hold refuses the whole call.
-     */
-    bulkAssignExtensions(ids: string[], extRefs: string[]): Promise<unknown>;
-    listGroups(signal?: AbortSignal): Promise<Group[]>;
-    getGroup(id: string, signal?: AbortSignal): Promise<Group>;
-    createGroup(body: CreateGroupBody): Promise<Group>;
-    updateGroup(id: string, body: UpdateGroupBody): Promise<Group>;
-    deleteGroup(id: string): Promise<void>;
-    listPresets(signal?: AbortSignal): Promise<Preset[]>;
-    getPreset(id: string, signal?: AbortSignal): Promise<Preset>;
-    createPreset(body: CreatePresetBody): Promise<Preset>;
-    updatePreset(id: string, body: UpdatePresetBody): Promise<Preset>;
-    deletePreset(id: string): Promise<void>;
-    listVideoPresets(signal?: AbortSignal): Promise<VideoPreset[]>;
-    getVideoPreset(id: string, signal?: AbortSignal): Promise<VideoPreset>;
-    /** The daemon validates `config` strictly and names the failing field path. */
-    createVideoPreset(body: {
-        name: string;
-        config?: Record<string, unknown>;
-    }): Promise<VideoPreset>;
-    /** A built-in preset refuses edits. Duplicate it and edit the copy. */
-    updateVideoPreset(id: string, body: {
-        name?: string;
-        config?: Record<string, unknown>;
-    }): Promise<VideoPreset>;
-    /** The only way to make a built-in preset yours: copy, then edit the copy. */
-    duplicateVideoPreset(id: string, body?: {
-        name?: string;
-    }): Promise<VideoPreset>;
-    deleteVideoPreset(id: string): Promise<void>;
-    /** One still of the sample film under an UNSAVED config, drawn by the daemon's own renderer.
-     *  `moment` wins over `frame`; both absent means the daemon's default moment. */
-    previewVideoPreset(body: VideoPresetPreviewBody, signal?: AbortSignal): Promise<VideoPresetPreview>;
-    /** A clip of the sample film, blocking until it is encoded (the editor uses the SSE form of the
-     *  same route; a script waits). Fetch the bytes with `downloadVideoPresetClip`. */
-    previewVideoPresetClip(body: VideoPresetClipBody, signal?: AbortSignal): Promise<VideoPresetClip>;
-    /** The clip's MP4 bytes. */
-    downloadVideoPresetClip(id: string, signal?: AbortSignal): Promise<ArtifactBytes>;
-    /**
-     * The values a preset's `constraints` may take. Ask rather than hardcode: the
-     * region list comes from the daemon's embedded persona model, so a pinned copy
-     * drifts the moment that model changes and every create 400s.
-     */
-    getPersonaConstraints(signal?: AbortSignal): Promise<PersonaConstraintOptions>;
-    /** The list carries `used_by` per row; `getProxy` below does not. */
-    listProxies(signal?: AbortSignal): Promise<ProxyRow[]>;
-    getProxy(id: string, signal?: AbortSignal): Promise<Proxy>;
-    createProxy(body: CreateProxyBody): Promise<Proxy>;
-    updateProxy(id: string, body: UpdateProxyBody): Promise<Proxy>;
-    deleteProxy(id: string): Promise<void>;
-    /** Health + geo check (exit-ip/country/healthy + JA4↔JA4T verdict). */
-    checkProxy(id: string): Promise<ProxyCheckResult>;
-    /**
-     * Probe a proxy config WITHOUT persisting it: validate before you commit.
-     * Pass `id` (and omit the credentials) to probe an existing proxy's stored,
-     * write-only credentials in an edit form.
-     */
-    checkProxyConfig(body: CheckProxyConfigBody): Promise<ProxyCheckResult>;
-    /** Queue a run → the status right after queueing. `409` if not running / already running. */
-    startAudit(profileId: string): Promise<AuditStatus>;
-    /** State plus the last stored report. */
-    getAudit(profileId: string, signal?: AbortSignal): Promise<AuditStatus>;
-    /** Which exit addresses this profile owns, and how far the rule reaches.
-     *
-     * `scope` is `'machine'` while this computer has no account key. That is the
-     * ordinary state of a second machine until sync is unlocked there once, and it is
-     * reported rather than hidden: believing the rule spans three machines when it
-     * spans one is worse than knowing. */
-    getExitStatus(profileId: string, signal?: AbortSignal): Promise<ExitStatus>;
-    exportSession(profileId: string, body: SessionExportBody): Promise<SessionExportResult>;
-    importSession(profileId: string, body: SessionImportBody): Promise<unknown>;
-    sendInput(profileId: string, body: TrustedInputBody): Promise<unknown>;
     getMetrics(signal?: AbortSignal): Promise<Metrics>;
     /**
      * Is remote access on for this machine?
@@ -2809,6 +5312,20 @@ declare class ScalebrowserClient extends ClientCore {
      * exists for the narrower case (`updateProfile` with `exit_exclusive`).
      */
     setExitRule(enabled: boolean, signal?: AbortSignal): Promise<ExitRuleStatus>;
+    /**
+     * Which optional MCP tool groups agents on this machine see.
+     *
+     * Agents see the basic tools by default; video, tasks, profile management,
+     * the captcha helpers, the extras and the developer tools are one switch each.
+     */
+    getAgentTools(signal?: AbortSignal): Promise<AgentTools>;
+    /**
+     * Turn one tool group on or off for every agent on this machine.
+     *
+     * It applies to the next tool list an agent asks for. A session that listed
+     * its tools before keeps that list until it reconnects.
+     */
+    setAgentToolGroup(group: ToolGroupId, enabled: boolean, signal?: AbortSignal): Promise<AgentTools>;
     /** Subscribe to lifecycle events. Returns an unsubscribe function. */
     subscribeEvents(handlers: StreamHandlers): () => void;
     /** `for await (const event of client.events())` over lifecycle events. */
@@ -2824,7 +5341,7 @@ declare class ScalebrowserClient extends ClientCore {
      */
     launch(profileId: string, body?: StartProfileBody): Promise<LaunchHandle>;
 }
-interface ScalebrowserClient extends IdentityApi, RunsApi, VideosApi, ControlApi, ExtensionsApi, TasksApi {
+interface ScalebrowserClient extends ProfilesApi, PresetsApi, ProxiesApi, IdentityApi, RunsApi, VideosApi, ControlApi, ExtensionsApi, TasksApi, WorkflowsApi, WorkflowRunsApi, WorkflowAiApi, WorkflowSyncApi, WorkflowSharesApi, WorkflowAgencyApi, TablesApi {
 }
 
 /**
@@ -2864,12 +5381,22 @@ declare const ErrorCode: {
      * for a term to run out, let the daemon draw again, or turn exclusivity off for
      * this profile. */
     readonly ExitAddressTaken: 4013;
+    /** The plan does not allow this: a 4th profile or workflow on Free, a schedule
+     * or webhook trigger on Free, or another feature the plan leaves out.
+     * Distinct from ConcurrencyLimit (4008 = too many browsers at once, free one or
+     * upgrade): here nothing is running too much, the plan itself stops it. The
+     * body's `plan_limit` names which limit, the allowed number, the plan and
+     * whether the 7-day trial is still open. */
+    readonly PlanLimit: 4014;
 };
 type ErrorCodeValue = (typeof ErrorCode)[keyof typeof ErrorCode];
-/** Error body shape: `{ code, message }`. */
+/** Error body shape: `{ code, message }`, with `reason` where one numeric code covers several cases. */
 interface ApiErrorBody {
     code?: number;
     message?: string;
+    /** A text code naming the case, such as `workflow_edit_locked`; its payload sits beside it. */
+    reason?: string;
+    [key: string]: unknown;
 }
 /** Base class for every error this SDK throws, so callers can `catch` one type. */
 declare class ScalebrowserError extends Error {
@@ -2883,6 +5410,8 @@ declare class ScalebrowserError extends Error {
 declare class ApiError extends ScalebrowserError {
     readonly status: number;
     readonly code?: number;
+    /** The text code of the case, where the daemon names one. */
+    readonly reason?: string;
     readonly body?: ApiErrorBody;
     constructor(status: number, body?: ApiErrorBody, fallbackMessage?: string);
     /** True for auth failures that must trigger re-authentication. */
@@ -2921,6 +5450,6 @@ declare function errorMessage(err: unknown): string;
  * ```
  */
 
-declare const VERSION = "1.1.0";
+declare const VERSION = "1.3.0";
 
-export { type Account, type ActivitySnapshot, type AgentRun, ApiError, type ApiErrorBody, type ArtifactBytes, type ArtifactPutResult, type AttachOptions, type AudioStatus, type AuditDetectorReport, type AuditReport, type AuditStatus, type AuditVerdict, type BindInboxBody, type BlockedExport, type CdpConnectOptions, CdpError, type CdpEvent, CdpSession, type Chapter, type ClickOptions, type CodecsStatus, type Connection, type CreateGroupBody, type CreateInboxBody, type CreatePresetBody, type CreateTasksBody, type CreateTasksResult, DEFAULT_CAPACITY, type DeleteInterruptionRuleParams, type EffectiveInterruptionLock, ErrorCode, type ErrorCodeValue, type EvaluateOptions, type ExitClaim, type ExitRuleStatus, type ExitScope, type ExitStatus, type ExportPresetName, type ExtraOutput, type FetchLike, GEO_MODES, type GeoMode, type GoalSource, type Group, type HealthStatus, type Inbox, type InboxBinding, type InboxBindings, type InboxChannel, type InputClient, type InterruptionChoice, type InterruptionLock, type InterruptionLockRow, type InterruptionLockView, type InterruptionRuleRow, type LaunchHandle, type ListRunsParams, type ListStepsParams, type ListTasksParams, type ListVideosParams, type MediaAsset, type MediaKind, type MusicBed, type NarrationLine, type NavigateOptions, NetworkError, type OsFamily, type OutcomeSource, PROXY_KINDS, type PasskeyRow, type PatchTaskBody, type PersonaConstraintOptions, type Preset, type PresetConfig, type PresetConstraints, type PreviewHidden, type PreviewMoment, type Profile, type ProfileActivity, type ProfileMemory, type ProfileTask, type ProtectionLevel, type ProtectionStatus, type Proxy, type ProxyKind, type ProxyRow, type ProxyUsage, ROTATIONS, RUNTIME_STATES, type ReadyStatus, type Recording, type RecordingKind, type RecordingState, type RemoteStatus, type RenderProgress, type RenderRequestBody, type RenderStage, type RevealCookiesBody, type RevealCookiesResult, type RevealedCookie, type Rotation, type RunActor, type RunOutcome, type RunStep, type RuntimeState, ScalebrowserClient, type ScalebrowserClientOptions, ScalebrowserError, type ScrollOptions, type SecretBindingMode, type SecretDeleteResult, type SecretKind, type SecretListResult, type SecretOrigin, type SecretPatchBody, type SecretRow, type SecretRunBody, type SecretRunMention, type SecretRunResult, type SecretScrubResult, type SecretState, type SessionExportBody, type SessionExportResult, type SessionImportBody, type SessionKind, type SetInterruptionLockBody, type SetInterruptionRuleBody, type ShareLinkLocal, type ShareStatus, type ShotFocus, type ShotIntent, type StepKind, type StepTarget, type StreamHandlers, type StreamParams, type StreamStatus, type TaskState, type TimestampState, type TranscriptWord, type TrustedInputBody, type TtsProviderView, type TtsVerifyResult, type UpdateGroupBody, type UpdateInboxBody, type UpdatePresetBody, VERSION, type Video, type VideoAccessGrant, type VideoAssetName, type VideoAssets, type VideoBackground, type VideoCard, type VideoDestination, type VideoFlags, type VideoPreset, type VideoPresetClip, type VideoPresetClipBody, type VideoPresetClipProgress, type VideoPresetClipStarted, type VideoPresetConfig, type VideoPresetPreview, type VideoPresetPreviewBody, type VideoState, type VideosPage, type VideosStorage, type WriteMemoryBody, deriveMetricsFromProfiles, errorMessage, eventStream, openCdpSession, parseSseFrame, subscribeEvents };
+export { type Account, type ActivitySnapshot, type AdoptResult, type AgencyAiKeyOptions, type AgencyClient, type AgencyClientList, type AgencyDistribution, type AgencySeats, type AgentRun, type AgentToolGroup, type AgentTools, type AiInvocation, type AiInvocationsParams, type AiSettings, type AiSource, ApiError, type ApiErrorBody, type Approval, type ApprovalWay, type ApprovalWebhook, type ArtifactBytes, type ArtifactPutResult, type AttachOptions, type AudioStatus, type AuditDetectorReport, type AuditReport, type AuditStatus, type AuditVerdict, type AuthorKind, type BindInboxBody, type BlockedExport, type BrandView, type CdpConnectOptions, CdpError, type CdpEvent, CdpSession, type CellValue, type Chapter, type ClickOptions, type ClientBriefModeSet, type CodeCandidate, type CodeRights, type CodeTrust, type CodecsStatus, type Column, type ColumnKind, type ColumnType, type ConnectGoogleBody, type Connection, type CreateAiSourceBody, type CreateGroupBody, type CreateInboxBody, type CreatePresetBody, type CreateTableBody, type CreateTasksBody, type CreateTasksResult, type CreateWorkflowBody, DEFAULT_CAPACITY, type DecideApprovalBody, type DecideWorkflowRunBody, type DeleteInterruptionRuleParams, type DeletePreview, type DeleteWorkflowParams, type Diagnostic, type DiagnosticSeverity, type DiffEdge, type DiffNode, type DiffNodeChange, type DiffWorkflowParams, type EditLockView, type EditOp, type EditResult, type EditTableBody, type EditTableResult, type EditWorkflowBody, type EffectiveInterruptionLock, type EmergencyStopResult, ErrorCode, type ErrorCodeValue, type EvaluateOptions, type ExitClaim, type ExitRuleStatus, type ExitScope, type ExitStatus, type ExportFormat, type ExportPresetName, type ExtraOutput, type ExtractResult, type ExtractWorkflowBody, type FastDomain, type FastDomains, type FetchLike, type ForkPreview, type ForkWorkflowRunBody, type ForwardState, GEO_MODES, type GeoMode, type GetWorkflowParams, type GetWorkflowRunParams, type GoalSource, type GoogleConnection, type GrantedFolder, type Group, type HealthStatus, type ImportMode, type ImportResult, type ImportTableParams, type ImportedWorkflow, type Inbox, type InboxBinding, type InboxBindings, type InboxChannel, type InboxLink, type InputClient, type InstantiatedTemplate, type InterruptionChoice, type InterruptionDevice, type InterruptionLock, type InterruptionLockRow, type InterruptionLockView, type InterruptionRuleRow, type LaunchHandle, type LinkSheetBody, type ListNodeTypesParams, type ListPendingInterruptionsOptions, type ListRowsParams, type ListRunsParams, type ListStepsParams, type ListTasksParams, type ListVideosParams, type ListWorkflowRunStepsParams, type ListWorkflowRunsParams, type LoopSummary, type MediaAsset, type MediaKind, type MusicBed, type NarrationLine, type NavigateOptions, NetworkError, type NodeId, type NodeRunState, type NodeTypeInfo, type NodeTypeOutput, type OsFamily, type OutcomeSource, PROXY_KINDS, type PasskeyRow, type PatchState, type PatchTaskBody, type PendingInterruption, type PendingInterruptions, type PersonaConstraintOptions, type Preset, type PresetConfig, type PresetConstraints, type PreviewHidden, type PreviewMoment, type Profile, type ProfileActivity, type ProfileHome, type ProfileMemory, type ProfileTask, type ProtectionLevel, type ProtectionStatus, type Proxy, type ProxyKind, type ProxyRow, type ProxyUsage, type QueueEntry, ROTATIONS, RUNTIME_STATES, type ReadinessFixKey, type ReadinessItem, type ReadinessStatus, type ReadyStatus, type Recording, type RecordingKind, type RecordingState, type ReferenceOutput, type ReferenceSource, type RemoteStatus, type RenderProgress, type RenderRequestBody, type RenderStage, type RepairApplied, type RepairAttempt, type RepairFigures, type RepairNodeFigures, type RepairPatch, type RepairRate, type RepairSpread, type RepairToAdopt, type RepairView, type RequestHeader, type RequestShape, type RespondInterruptionBody, type RespondInterruptionResult, type Retention, type RevealCookiesBody, type RevealCookiesResult, type RevealInboxBody, type RevealInboxResult, type RevealRequestBody, type RevealRequestResult, type RevealWorkflowVariableBody, type RevealedCookie, type RevealedMessage, type RevealedVariable, type RevertResult, type RevertWorkflowBody, type RevertedRepair, type ReviewItem, type Rotation, type Row, type RowsPage, type RunActor, type RunBrief, type RunOutcome, type RunStartResult, type RunStep, type RunView, type RuntimeState, type SaveOutcome, type SaveWorkflowVersionBody, ScalebrowserClient, type ScalebrowserClientOptions, ScalebrowserError, type ScrollOptions, type SecretBindingMode, type SecretDeleteResult, type SecretKind, type SecretListResult, type SecretOrigin, type SecretPatchBody, type SecretRow, type SecretRunBody, type SecretRunMention, type SecretRunResult, type SecretScrubResult, type SecretState, type SessionExportBody, type SessionExportResult, type SessionImportBody, type SessionKind, type SetInterruptionLockBody, type SetInterruptionRuleBody, type SetWlSharingBody, type SetWorkflowSwitchBody, type SetWorkflowVariableBody, type SettledInterruption, type ShareLinkLocal, type ShareRevoked, type ShareStatus, type ShotFocus, type ShotIntent, type ShotRef, type SourceKind, type SpaceMachine, type StartWorkflowRunBody, type StartWorkflowRunParams, type StepKind, type StepStatus, type StepTarget, type StreamHandlers, type StreamParams, type StreamStatus, type TableMeta, type TableOp, type TaskState, type TimestampState, type ToolGroupId, type TranscriptWord, type TrustedInputBody, type TtsProviderView, type TtsVerifyResult, type UnknownEffectPolicy, type UnsentChange, type UpdateAiSourceBody, type UpdateGroupBody, type UpdateInboxBody, type UpdatePresetBody, type UpdateTableBody, type UsageRow, VERSION, type ValueMark, type VariableScope, type VariableState, type VersionKind, type Video, type VideoAccessGrant, type VideoAssetName, type VideoAssets, type VideoBackground, type VideoCard, type VideoDestination, type VideoFlags, type VideoPreset, type VideoPresetClip, type VideoPresetClipBody, type VideoPresetClipProgress, type VideoPresetClipStarted, type VideoPresetConfig, type VideoPresetPreview, type VideoPresetPreviewBody, type VideoState, type VideosPage, type VideosStorage, type WaitReason, type WlBriefMode, type WlDeviceClaim, type WlLicence, type WlSharing, type WorkflowDetail, type WorkflowDiff, type WorkflowDoc, type WorkflowEdge, type WorkflowFileAccess, type WorkflowFire, type WorkflowFireState, type WorkflowFiresParams, type WorkflowForward, type WorkflowHook, type WorkflowHookList, type WorkflowMachines, type WorkflowNode, type WorkflowQueue, type WorkflowReadiness, type WorkflowRun, type WorkflowRunFile, type WorkflowRunKind, type WorkflowRunStatus, type WorkflowShareLink, type WorkflowStatusReason, type WorkflowStep, type WorkflowSummary, type WorkflowSwitch, type WorkflowSyncView, type WorkflowTemplate, type WorkflowTriggerKind, type WorkflowUsageParams, type WorkflowVersion, type WorkflowVersionDoc, type WriteMemoryBody, deriveMetricsFromProfiles, errorMessage, eventStream, openCdpSession, parseSseFrame, subscribeEvents };