@claudexor/schema 1.0.0

package/dist/control.d.ts

@@ -0,0 +1,4226 @@
+import { z } from "zod";
+/** Project context depth. The "deep" tier never shipped a distinct behavior
+ * (v0.15 triage): auto is the only mode; off exists solely on projections of
+ * no-project runs. */
+export declare const RunScopeContext: z.ZodEnum<["auto"]>;
+export type RunScopeContext = z.infer<typeof RunScopeContext>;
+export declare const RunScope: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"project">;
+    root: z.ZodString;
+    context: z.ZodDefault<z.ZodEnum<["auto"]>>;
+}, "strict", z.ZodTypeAny, {
+    kind: "project";
+    root: string;
+    context: "auto";
+}, {
+    kind: "project";
+    root: string;
+    context?: "auto" | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"none">;
+}, "strict", z.ZodTypeAny, {
+    kind: "none";
+}, {
+    kind: "none";
+}>]>;
+export type RunScope = z.infer<typeof RunScope>;
+export declare const RunExecution: z.ZodObject<{
+    isolation: z.ZodDefault<z.ZodEnum<["envelope", "live"]>>;
+}, "strict", z.ZodTypeAny, {
+    isolation: "live" | "envelope";
+}, {
+    isolation?: "live" | "envelope" | undefined;
+}>;
+export type RunExecution = z.infer<typeof RunExecution>;
+export declare const ControlReviewerPanelEntry: z.ZodObject<{
+    /** Explicit reviewer harness id. Repeated harness ids are allowed so one
+     * native provider can review through multiple requested models. */
+    harness: z.ZodString;
+    /** Optional per-reviewer model hint, passed to that harness only. */
+    model: z.ZodOptional<z.ZodString>;
+    /** Optional per-reviewer effort hint, passed to that harness only. */
+    effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
+}, "strict", z.ZodTypeAny, {
+    harness: string;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    model?: string | undefined;
+}, {
+    harness: string;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    model?: string | undefined;
+}>;
+export type ControlReviewerPanelEntry = z.infer<typeof ControlReviewerPanelEntry>;
+export declare const ControlRunStartRequest: z.ZodObject<{
+    prompt: z.ZodDefault<z.ZodString>;
+    /** Inbound files/images for this turn; the daemon resolves each to a scoped
+     *  on-disk Attachment before the run spec is built. */
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<["image", "file"]>>;
+        mime: z.ZodDefault<z.ZodString>;
+        name: z.ZodDefault<z.ZodString>;
+        data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        path: string | null;
+        kind: "image" | "file";
+        mime: string;
+        name: string;
+        data: string | null;
+    }, {
+        path?: string | null | undefined;
+        kind?: "image" | "file" | undefined;
+        mime?: string | undefined;
+        name?: string | undefined;
+        data?: string | null | undefined;
+    }>, "many">>;
+    mode: z.ZodDefault<z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>>;
+    scope: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        root: z.ZodString;
+        context: z.ZodDefault<z.ZodEnum<["auto"]>>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "project";
+        root: string;
+        context: "auto";
+    }, {
+        kind: "project";
+        root: string;
+        context?: "auto" | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"none">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "none";
+    }, {
+        kind: "none";
+    }>]>>;
+    execution: z.ZodDefault<z.ZodObject<{
+        isolation: z.ZodDefault<z.ZodEnum<["envelope", "live"]>>;
+    }, "strict", z.ZodTypeAny, {
+        isolation: "live" | "envelope";
+    }, {
+        isolation?: "live" | "envelope" | undefined;
+    }>>;
+    harnesses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    primaryHarness: z.ZodOptional<z.ZodString>;
+    portfolio: z.ZodOptional<z.ZodEnum<["daily-rich", "balanced", "cheapest", "strongest", "burn", "subscription-first", "api-overflow", "conserve-claude", "conserve-codex"]>>;
+    /** Scalar model convenience: expands to the RESOLVED PRIMARY harness only
+     * (never the pool). With a multi-harness pool and no primary it is
+     * rejected — use `models` instead (INV-103). */
+    model: z.ZodOptional<z.ZodString>;
+    /** Harness-scoped model map (harness id → model id). Specific beats
+     * general: an entry here wins over the scalar `model` and over the
+     * per-harness settings default. */
+    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
+    reviewerModels: z.ZodOptional<z.ZodRecord<z.ZodEnum<["openai", "anthropic", "google", "cursor", "opencode", "xai", "local", "unknown"]>, z.ZodString>>;
+    reviewerEfforts: z.ZodOptional<z.ZodRecord<z.ZodEnum<["openai", "anthropic", "google", "cursor", "opencode", "xai", "local", "unknown"]>, z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>>;
+    n: z.ZodOptional<z.ZodNumber>;
+    attempts: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    /** agent flag: iterate until the convergence predicate is clean (no fixed cap). */
+    untilClean: z.ZodOptional<z.ZodBoolean>;
+    /** audit flag: bounded read-only research swarm (the old `explore`). */
+    swarm: z.ZodOptional<z.ZodBoolean>;
+    /** agent flag: create-from-scratch intent (the old `create` mode). */
+    create: z.ZodOptional<z.ZodBoolean>;
+    /** Best-of-N synthesis policy. `auto` (default) only synthesizes a 3rd
+     * candidate when n>=3 and candidates genuinely complement; `always`/`never`
+     * force it. Threaded to the orchestrator's decideSynthesis. */
+    synthesis: z.ZodOptional<z.ZodEnum<["auto", "always", "never"]>>;
+    maxUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    /** Requested access profile. Effective access is derived by the engine and never client-supplied. */
+    access: z.ZodOptional<z.ZodEnum<["readonly", "workspace_write", "full", "external_sandbox_full", "inherit_native"]>>;
+    web: z.ZodOptional<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+    externalContextPolicy: z.ZodOptional<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+    /** Opt this run into the agent-driven browser (Playwright MCP). Honored only
+     *  for browser-capable harnesses when web policy is not `off`. */
+    browser: z.ZodOptional<z.ZodBoolean>;
+    tests: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Typed per-run approval for changing auto-protected gate/test paths. This
+     * does not bypass built-in critical/security path human gates. */
+    protectedPathApprovals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        reason?: string | undefined;
+    }, {
+        path: string;
+        reason?: string | undefined;
+    }>, "many">>;
+    specPath: z.ZodOptional<z.ZodString>;
+    specId: z.ZodOptional<z.ZodString>;
+    specHash: z.ZodOptional<z.ZodString>;
+    /** Thread/session linkage: a run is a turn inside a thread. */
+    threadId: z.ZodOptional<z.ZodString>;
+    /** INTERNAL single-writer handoff: control-api pre-creates the turn and
+     * passes its id to the daemon runner. REJECTED (400) when supplied by a
+     * client on POST /runs — a foreign turnId could rebind another thread's
+     * lineage; POST /threads/:id/turns is the public turn surface. */
+    turnId: z.ZodOptional<z.ZodString>;
+    parentRunId: z.ZodOptional<z.ZodString>;
+    /** When set, this turn implements an approved plan: the engine prefixes the
+     * parent plan run's final/plan.md into the prompt (mode is forced to agent). */
+    planRunId: z.ZodOptional<z.ZodString>;
+    /** Explicit reviewer panel. When present it overrides the legacy
+     * per-provider-family reviewerModels/reviewerEfforts maps and preserves
+     * duplicate harness entries for multi-model same-provider reviews. */
+    reviewerPanel: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Explicit reviewer harness id. Repeated harness ids are allowed so one
+         * native provider can review through multiple requested models. */
+        harness: z.ZodString;
+        /** Optional per-reviewer model hint, passed to that harness only. */
+        model: z.ZodOptional<z.ZodString>;
+        /** Optional per-reviewer effort hint, passed to that harness only. */
+        effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
+    }, "strict", z.ZodTypeAny, {
+        harness: string;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+        model?: string | undefined;
+    }, {
+        harness: string;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+        model?: string | undefined;
+    }>, "many">>;
+    /** Per-run auth route override (subscription/api_key/auto). */
+    authPreference: z.ZodOptional<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+    /** How much the orchestrate planner may act without confirmation
+     * (suggest/auto_safe/auto_full). Only meaningful for mode=orchestrate;
+     * consumed by the executor in runOrchestrate. */
+    autonomy: z.ZodOptional<z.ZodEnum<["suggest", "auto_safe", "auto_full"]>>;
+    /** Orchestrate executor: cap on plan tool calls. Only meaningful for
+     * mode=orchestrate; consumed by executeOrchestratePlan. */
+    maxToolCalls: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    prompt: string;
+    mode: "ask" | "plan" | "audit" | "agent" | "orchestrate";
+    scope: {
+        kind: "project";
+        root: string;
+        context: "auto";
+    } | {
+        kind: "none";
+    };
+    execution: {
+        isolation: "live" | "envelope";
+    };
+    access?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    web?: "off" | "auto" | "cached" | "live" | undefined;
+    attachments?: {
+        path: string | null;
+        kind: "image" | "file";
+        mime: string;
+        name: string;
+        data: string | null;
+    }[] | undefined;
+    browser?: boolean | undefined;
+    turnId?: string | undefined;
+    planRunId?: string | undefined;
+    models?: Record<string, string> | undefined;
+    harnesses?: string[] | undefined;
+    tests?: string[] | undefined;
+    portfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    autonomy?: "suggest" | "auto_safe" | "auto_full" | undefined;
+    n?: number | undefined;
+    model?: string | undefined;
+    primaryHarness?: string | undefined;
+    reviewerModels?: Partial<Record<"openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown", string>> | undefined;
+    reviewerEfforts?: Partial<Record<"openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown", "low" | "medium" | "high" | "xhigh" | "max">> | undefined;
+    attempts?: number | null | undefined;
+    untilClean?: boolean | undefined;
+    swarm?: boolean | undefined;
+    create?: boolean | undefined;
+    synthesis?: "auto" | "never" | "always" | undefined;
+    maxUsd?: number | null | undefined;
+    externalContextPolicy?: "off" | "auto" | "cached" | "live" | undefined;
+    protectedPathApprovals?: {
+        path: string;
+        reason?: string | undefined;
+    }[] | undefined;
+    specPath?: string | undefined;
+    specId?: string | undefined;
+    specHash?: string | undefined;
+    threadId?: string | undefined;
+    parentRunId?: string | undefined;
+    reviewerPanel?: {
+        harness: string;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+        model?: string | undefined;
+    }[] | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    maxToolCalls?: number | undefined;
+}, {
+    prompt?: string | undefined;
+    access?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    web?: "off" | "auto" | "cached" | "live" | undefined;
+    attachments?: {
+        path?: string | null | undefined;
+        kind?: "image" | "file" | undefined;
+        mime?: string | undefined;
+        name?: string | undefined;
+        data?: string | null | undefined;
+    }[] | undefined;
+    browser?: boolean | undefined;
+    mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    turnId?: string | undefined;
+    planRunId?: string | undefined;
+    models?: Record<string, string> | undefined;
+    harnesses?: string[] | undefined;
+    tests?: string[] | undefined;
+    portfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    autonomy?: "suggest" | "auto_safe" | "auto_full" | undefined;
+    n?: number | undefined;
+    model?: string | undefined;
+    scope?: {
+        kind: "project";
+        root: string;
+        context?: "auto" | undefined;
+    } | {
+        kind: "none";
+    } | undefined;
+    execution?: {
+        isolation?: "live" | "envelope" | undefined;
+    } | undefined;
+    primaryHarness?: string | undefined;
+    reviewerModels?: Partial<Record<"openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown", string>> | undefined;
+    reviewerEfforts?: Partial<Record<"openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown", "low" | "medium" | "high" | "xhigh" | "max">> | undefined;
+    attempts?: number | null | undefined;
+    untilClean?: boolean | undefined;
+    swarm?: boolean | undefined;
+    create?: boolean | undefined;
+    synthesis?: "auto" | "never" | "always" | undefined;
+    maxUsd?: number | null | undefined;
+    externalContextPolicy?: "off" | "auto" | "cached" | "live" | undefined;
+    protectedPathApprovals?: {
+        path: string;
+        reason?: string | undefined;
+    }[] | undefined;
+    specPath?: string | undefined;
+    specId?: string | undefined;
+    specHash?: string | undefined;
+    threadId?: string | undefined;
+    parentRunId?: string | undefined;
+    reviewerPanel?: {
+        harness: string;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+        model?: string | undefined;
+    }[] | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    maxToolCalls?: number | undefined;
+}>;
+export type ControlRunStartRequest = z.infer<typeof ControlRunStartRequest>;
+/** Harness ids that have a managed setup flow (shared by the async setup-jobs path). */
+export declare const ControlHarnessSetupHarness: z.ZodEnum<["codex", "claude", "cursor", "opencode", "raw"]>;
+export type ControlHarnessSetupHarness = z.infer<typeof ControlHarnessSetupHarness>;
+export declare const ControlSetupJobAction: z.ZodEnum<["install", "login", "doctor", "store_key"]>;
+export type ControlSetupJobAction = z.infer<typeof ControlSetupJobAction>;
+export declare const ControlSetupJobState: z.ZodEnum<["queued", "running", "waiting_for_input", "succeeded", "failed", "cancelled", "not_supported"]>;
+export type ControlSetupJobState = z.infer<typeof ControlSetupJobState>;
+export declare const ControlSetupJobCreateRequest: z.ZodObject<{
+    harness: z.ZodEnum<["codex", "claude", "cursor", "opencode", "raw"]>;
+    action: z.ZodEnum<["install", "login", "doctor", "store_key"]>;
+}, "strict", z.ZodTypeAny, {
+    harness: "cursor" | "opencode" | "raw" | "codex" | "claude";
+    action: "install" | "login" | "doctor" | "store_key";
+}, {
+    harness: "cursor" | "opencode" | "raw" | "codex" | "claude";
+    action: "install" | "login" | "doctor" | "store_key";
+}>;
+export type ControlSetupJobCreateRequest = z.infer<typeof ControlSetupJobCreateRequest>;
+export declare const ControlSetupJob: z.ZodObject<{
+    jobId: z.ZodString;
+    harness: z.ZodEnum<["codex", "claude", "cursor", "opencode", "raw"]>;
+    action: z.ZodEnum<["install", "login", "doctor", "store_key"]>;
+    state: z.ZodEnum<["queued", "running", "waiting_for_input", "succeeded", "failed", "cancelled", "not_supported"]>;
+    command: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    guideUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    logPath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    message: z.ZodString;
+    riskFlags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    requiresConfirmation: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodString;
+    startedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    firstOutputAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    lastOutputAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    finishedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    retryCount: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    command: string | null;
+    state: "cancelled" | "failed" | "running" | "queued" | "waiting_for_input" | "succeeded" | "not_supported";
+    harness: "cursor" | "opencode" | "raw" | "codex" | "claude";
+    action: "install" | "login" | "doctor" | "store_key";
+    jobId: string;
+    guideUrl: string | null;
+    logPath: string | null;
+    riskFlags: string[];
+    requiresConfirmation: boolean;
+    createdAt: string;
+    startedAt: string | null;
+    firstOutputAt: string | null;
+    lastOutputAt: string | null;
+    finishedAt: string | null;
+    retryCount: number;
+}, {
+    message: string;
+    state: "cancelled" | "failed" | "running" | "queued" | "waiting_for_input" | "succeeded" | "not_supported";
+    harness: "cursor" | "opencode" | "raw" | "codex" | "claude";
+    action: "install" | "login" | "doctor" | "store_key";
+    jobId: string;
+    createdAt: string;
+    command?: string | null | undefined;
+    guideUrl?: string | null | undefined;
+    logPath?: string | null | undefined;
+    riskFlags?: string[] | undefined;
+    requiresConfirmation?: boolean | undefined;
+    startedAt?: string | null | undefined;
+    firstOutputAt?: string | null | undefined;
+    lastOutputAt?: string | null | undefined;
+    finishedAt?: string | null | undefined;
+    retryCount?: number | undefined;
+}>;
+export type ControlSetupJob = z.infer<typeof ControlSetupJob>;
+export declare const ControlSetupJobEvent: z.ZodObject<{
+    jobId: z.ZodString;
+    seq: z.ZodNumber;
+    time: z.ZodString;
+    /** Only "status" is ever produced (v0.15 triage: the log/end kinds had no
+     * producer; SSE stream end is a transport frame, not a payload kind). */
+    kind: z.ZodEnum<["status"]>;
+    state: z.ZodOptional<z.ZodEnum<["queued", "running", "waiting_for_input", "succeeded", "failed", "cancelled", "not_supported"]>>;
+    message: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    kind: "status";
+    time: string;
+    jobId: string;
+    seq: number;
+    state?: "cancelled" | "failed" | "running" | "queued" | "waiting_for_input" | "succeeded" | "not_supported" | undefined;
+}, {
+    message: string;
+    kind: "status";
+    time: string;
+    jobId: string;
+    seq: number;
+    state?: "cancelled" | "failed" | "running" | "queued" | "waiting_for_input" | "succeeded" | "not_supported" | undefined;
+}>;
+export type ControlSetupJobEvent = z.infer<typeof ControlSetupJobEvent>;
+export declare const ControlSetupJobListResponse: z.ZodObject<{
+    jobs: z.ZodArray<z.ZodObject<{
+        jobId: z.ZodString;
+        harness: z.ZodEnum<["codex", "claude", "cursor", "opencode", "raw"]>;
+        action: z.ZodEnum<["install", "login", "doctor", "store_key"]>;
+        state: z.ZodEnum<["queued", "running", "waiting_for_input", "succeeded", "failed", "cancelled", "not_supported"]>;
+        command: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        guideUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        logPath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        message: z.ZodString;
+        riskFlags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        requiresConfirmation: z.ZodDefault<z.ZodBoolean>;
+        createdAt: z.ZodString;
+        startedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        firstOutputAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        lastOutputAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        finishedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        retryCount: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        command: string | null;
+        state: "cancelled" | "failed" | "running" | "queued" | "waiting_for_input" | "succeeded" | "not_supported";
+        harness: "cursor" | "opencode" | "raw" | "codex" | "claude";
+        action: "install" | "login" | "doctor" | "store_key";
+        jobId: string;
+        guideUrl: string | null;
+        logPath: string | null;
+        riskFlags: string[];
+        requiresConfirmation: boolean;
+        createdAt: string;
+        startedAt: string | null;
+        firstOutputAt: string | null;
+        lastOutputAt: string | null;
+        finishedAt: string | null;
+        retryCount: number;
+    }, {
+        message: string;
+        state: "cancelled" | "failed" | "running" | "queued" | "waiting_for_input" | "succeeded" | "not_supported";
+        harness: "cursor" | "opencode" | "raw" | "codex" | "claude";
+        action: "install" | "login" | "doctor" | "store_key";
+        jobId: string;
+        createdAt: string;
+        command?: string | null | undefined;
+        guideUrl?: string | null | undefined;
+        logPath?: string | null | undefined;
+        riskFlags?: string[] | undefined;
+        requiresConfirmation?: boolean | undefined;
+        startedAt?: string | null | undefined;
+        firstOutputAt?: string | null | undefined;
+        lastOutputAt?: string | null | undefined;
+        finishedAt?: string | null | undefined;
+        retryCount?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    jobs: {
+        message: string;
+        command: string | null;
+        state: "cancelled" | "failed" | "running" | "queued" | "waiting_for_input" | "succeeded" | "not_supported";
+        harness: "cursor" | "opencode" | "raw" | "codex" | "claude";
+        action: "install" | "login" | "doctor" | "store_key";
+        jobId: string;
+        guideUrl: string | null;
+        logPath: string | null;
+        riskFlags: string[];
+        requiresConfirmation: boolean;
+        createdAt: string;
+        startedAt: string | null;
+        firstOutputAt: string | null;
+        lastOutputAt: string | null;
+        finishedAt: string | null;
+        retryCount: number;
+    }[];
+}, {
+    jobs: {
+        message: string;
+        state: "cancelled" | "failed" | "running" | "queued" | "waiting_for_input" | "succeeded" | "not_supported";
+        harness: "cursor" | "opencode" | "raw" | "codex" | "claude";
+        action: "install" | "login" | "doctor" | "store_key";
+        jobId: string;
+        createdAt: string;
+        command?: string | null | undefined;
+        guideUrl?: string | null | undefined;
+        logPath?: string | null | undefined;
+        riskFlags?: string[] | undefined;
+        requiresConfirmation?: boolean | undefined;
+        startedAt?: string | null | undefined;
+        firstOutputAt?: string | null | undefined;
+        lastOutputAt?: string | null | undefined;
+        finishedAt?: string | null | undefined;
+        retryCount?: number | undefined;
+    }[];
+}>;
+export type ControlSetupJobListResponse = z.infer<typeof ControlSetupJobListResponse>;
+export declare const ControlSetupJobConfirmRequest: z.ZodObject<{
+    confirmed: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    confirmed: boolean;
+}, {
+    confirmed?: boolean | undefined;
+}>;
+export type ControlSetupJobConfirmRequest = z.infer<typeof ControlSetupJobConfirmRequest>;
+export declare const ControlSpecQuestionsRequest: z.ZodObject<{
+    prompt: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        root: z.ZodString;
+        context: z.ZodDefault<z.ZodEnum<["auto"]>>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "project";
+        root: string;
+        context: "auto";
+    }, {
+        kind: "project";
+        root: string;
+        context?: "auto" | undefined;
+    }>;
+    harnesses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Already-answered decisions from prior tiers; carried so each round goes
+     *  DEEPER instead of re-asking (multi-tier adaptive interview). */
+    priorDecisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        answer: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        question: string;
+        answer: string;
+    }, {
+        question: string;
+        answer: string;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    prompt: string;
+    scope: {
+        kind: "project";
+        root: string;
+        context: "auto";
+    };
+    harnesses?: string[] | undefined;
+    priorDecisions?: {
+        question: string;
+        answer: string;
+    }[] | undefined;
+}, {
+    prompt: string;
+    scope: {
+        kind: "project";
+        root: string;
+        context?: "auto" | undefined;
+    };
+    harnesses?: string[] | undefined;
+    priorDecisions?: {
+        question: string;
+        answer: string;
+    }[] | undefined;
+}>;
+export type ControlSpecQuestionsRequest = z.infer<typeof ControlSpecQuestionsRequest>;
+export declare const ControlSpecFreezeRequest: z.ZodObject<{
+    prompt: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        root: z.ZodString;
+        context: z.ZodDefault<z.ZodEnum<["auto"]>>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "project";
+        root: string;
+        context: "auto";
+    }, {
+        kind: "project";
+        root: string;
+        context?: "auto" | undefined;
+    }>;
+    planDir: z.ZodOptional<z.ZodString>;
+    plan: z.ZodOptional<z.ZodString>;
+    answers: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    /** Accumulated prior-tier interview decisions. Folded into the frozen
+     *  SpecPack's decided_tradeoffs so a MULTI-TIER spec carries every tier, not
+     *  just the last (mirror of ControlSpecQuestionsRequest.priorDecisions). */
+    priorDecisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        answer: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        question: string;
+        answer: string;
+    }, {
+        question: string;
+        answer: string;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    prompt: string;
+    scope: {
+        kind: "project";
+        root: string;
+        context: "auto";
+    };
+    plan?: string | undefined;
+    answers?: unknown[] | undefined;
+    priorDecisions?: {
+        question: string;
+        answer: string;
+    }[] | undefined;
+    planDir?: string | undefined;
+}, {
+    prompt: string;
+    scope: {
+        kind: "project";
+        root: string;
+        context?: "auto" | undefined;
+    };
+    plan?: string | undefined;
+    answers?: unknown[] | undefined;
+    priorDecisions?: {
+        question: string;
+        answer: string;
+    }[] | undefined;
+    planDir?: string | undefined;
+}>;
+export type ControlSpecFreezeRequest = z.infer<typeof ControlSpecFreezeRequest>;
+export declare const ControlRunStartInfo: z.ZodObject<{
+    jobId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
+    runDir: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    runId: string;
+    runDir: string;
+    jobId?: string | undefined;
+    taskId?: string | undefined;
+}, {
+    runId: string;
+    runDir: string;
+    jobId?: string | undefined;
+    taskId?: string | undefined;
+}>;
+export type ControlRunStartInfo = z.infer<typeof ControlRunStartInfo>;
+export declare const ControlRunState: z.ZodEnum<["queued", "running", "blocked", "succeeded", "no_op", "ungated", "review_not_run", "failed", "cancelled", "interrupted", "exhausted", "not_converged", "stuck_no_progress"]>;
+export type ControlRunState = z.infer<typeof ControlRunState>;
+export declare const ControlQueuedRunInfo: z.ZodObject<{
+    jobId: z.ZodString;
+    state: z.ZodEnum<["queued", "running", "blocked", "succeeded", "no_op", "ungated", "review_not_run", "failed", "cancelled", "interrupted", "exhausted", "not_converged", "stuck_no_progress"]>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+    jobId: string;
+    error?: string | undefined;
+}, {
+    state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+    jobId: string;
+    error?: string | undefined;
+}>;
+export type ControlQueuedRunInfo = z.infer<typeof ControlQueuedRunInfo>;
+export declare const RunFailure: z.ZodObject<{
+    phase: z.ZodDefault<z.ZodString>;
+    category: z.ZodDefault<z.ZodEnum<["validation", "project", "auth", "harness_unavailable", "harness_error", "budget", "policy", "cancelled", "internal", "unknown"]>>;
+    harnessId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    attemptId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    safeMessage: z.ZodString;
+    rawDetailRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    logRefs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    eventRefs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    runDir: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    nextActions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    runDir: string | null;
+    category: "validation" | "unknown" | "harness_error" | "auth" | "cancelled" | "budget" | "project" | "policy" | "harness_unavailable" | "internal";
+    phase: string;
+    harnessId: string | null;
+    attemptId: string | null;
+    safeMessage: string;
+    rawDetailRef: string | null;
+    logRefs: string[];
+    eventRefs: string[];
+    nextActions: string[];
+}, {
+    safeMessage: string;
+    runDir?: string | null | undefined;
+    category?: "validation" | "unknown" | "harness_error" | "auth" | "cancelled" | "budget" | "project" | "policy" | "harness_unavailable" | "internal" | undefined;
+    phase?: string | undefined;
+    harnessId?: string | null | undefined;
+    attemptId?: string | null | undefined;
+    rawDetailRef?: string | null | undefined;
+    logRefs?: string[] | undefined;
+    eventRefs?: string[] | undefined;
+    nextActions?: string[] | undefined;
+}>;
+export type RunFailure = z.infer<typeof RunFailure>;
+export declare const ControlProjectMetadata: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodEnum<["project", "none"]>>;
+    root: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    projectName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    context: z.ZodDefault<z.ZodEnum<["off", "auto"]>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "none" | "project";
+    root: string | null;
+    context: "off" | "auto";
+    projectName: string | null;
+}, {
+    kind?: "none" | "project" | undefined;
+    root?: string | null | undefined;
+    context?: "off" | "auto" | undefined;
+    projectName?: string | null | undefined;
+}>;
+export type ControlProjectMetadata = z.infer<typeof ControlProjectMetadata>;
+export declare const ControlWebEvidence: z.ZodObject<{
+    required: z.ZodDefault<z.ZodBoolean>;
+    /** Requested external-context policy for the run. */
+    mode: z.ZodDefault<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+    /** Mode the selected route actually executed (disclosed upgrades, e.g. claude cached->live). */
+    effectiveMode: z.ZodDefault<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+    attempted: z.ZodDefault<z.ZodBoolean>;
+    satisfied: z.ZodDefault<z.ZodBoolean>;
+    status: z.ZodDefault<z.ZodEnum<["none", "attempted", "satisfied", "failed", "unverified"]>>;
+    tool: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    target: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    errorSummary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    rawDetailRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** False when the run predates telemetry.yaml; surfaces must render "telemetry unavailable". */
+    available: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    status: "none" | "failed" | "attempted" | "unverified" | "satisfied";
+    target: string | null;
+    tool: string | null;
+    mode: "off" | "auto" | "cached" | "live";
+    required: boolean;
+    attempted: boolean;
+    rawDetailRef: string | null;
+    effectiveMode: "off" | "auto" | "cached" | "live";
+    satisfied: boolean;
+    errorSummary: string | null;
+    available: boolean;
+}, {
+    status?: "none" | "failed" | "attempted" | "unverified" | "satisfied" | undefined;
+    target?: string | null | undefined;
+    tool?: string | null | undefined;
+    mode?: "off" | "auto" | "cached" | "live" | undefined;
+    required?: boolean | undefined;
+    attempted?: boolean | undefined;
+    rawDetailRef?: string | null | undefined;
+    effectiveMode?: "off" | "auto" | "cached" | "live" | undefined;
+    satisfied?: boolean | undefined;
+    errorSummary?: string | null | undefined;
+    available?: boolean | undefined;
+}>;
+export type ControlWebEvidence = z.infer<typeof ControlWebEvidence>;
+/**
+ * Run-level route evidence projected from telemetry (observed model per
+ * attempt). `verified` is true only when an observed model was actually
+ * reported by the harness stream — never inferred from the request.
+ */
+export declare const ControlRouteInfo: z.ZodObject<{
+    requestedModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    observedModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    harnessId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    verified: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    verified: boolean;
+    harnessId: string | null;
+    requestedModel: string | null;
+    observedModel: string | null;
+}, {
+    verified?: boolean | undefined;
+    harnessId?: string | null | undefined;
+    requestedModel?: string | null | undefined;
+    observedModel?: string | null | undefined;
+}>;
+export type ControlRouteInfo = z.infer<typeof ControlRouteInfo>;
+/**
+ * Honest terminal outcome of a run, projected from final/work_product.yaml and
+ * the presence of final/answer.md. Answers "what did this turn actually do?" so
+ * a chat surface never shows a green "succeeded" next to nothing (the v0.9 plan
+ * bug): `kind:"plan"` means a plan was produced and NO files changed; `diffStat`
+ * is null unless a patch exists; `adopted` is true when the live in-place tree
+ * was actually mutated this turn (decoupled from a clean review — see applyState).
+ */
+export declare const RunApplyState: z.ZodEnum<["not_applied", "applied", "applied_review_blocked", "reverted"]>;
+export type RunApplyState = z.infer<typeof RunApplyState>;
+export declare const ControlRunResult: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodEnum<["patch", "answer", "plan", "report", "none"]>>;
+    diffStat: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        files: z.ZodNumber;
+        additions: z.ZodNumber;
+        deletions: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        files: number;
+        additions: number;
+        deletions: number;
+    }, {
+        files: number;
+        additions: number;
+        deletions: number;
+    }>>>;
+    blockers: z.ZodDefault<z.ZodNumber>;
+    /** True when the live in-place tree was mutated this turn (regardless of review). */
+    adopted: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+    /** Honest application state (decoupled from clean-terminal). */
+    applyState: z.ZodDefault<z.ZodEnum<["not_applied", "applied", "applied_review_blocked", "reverted"]>>;
+    /** Tree SHA before this turn mutated the in-place tree (revert restore target). */
+    preTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Tree SHA right after this turn's mutation (revert divergence fence: refuse
+     * to revert if the working tree has diverged from this since). */
+    postTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Revert metadata is available (the turn mutated the live tree in place and
+     * pre/post-turn snapshots were recorded), so a Revert affordance may be offered.
+     * This is NOT a live-safe guarantee: the server re-checks tree divergence at
+     * revert time and refuses (fail loud) if the working tree changed since. */
+    revertable: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    kind: "plan" | "none" | "patch" | "report" | "answer";
+    diffStat: {
+        files: number;
+        additions: number;
+        deletions: number;
+    } | null;
+    blockers: number;
+    adopted: boolean | null;
+    applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+    preTurnSha: string | null;
+    postTurnSha: string | null;
+    revertable: boolean;
+}, {
+    kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+    diffStat?: {
+        files: number;
+        additions: number;
+        deletions: number;
+    } | null | undefined;
+    blockers?: number | undefined;
+    adopted?: boolean | null | undefined;
+    applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+    preTurnSha?: string | null | undefined;
+    postTurnSha?: string | null | undefined;
+    revertable?: boolean | undefined;
+}>;
+export type ControlRunResult = z.infer<typeof ControlRunResult>;
+export declare const ControlRunSummary: z.ZodObject<{
+    jobId: z.ZodString;
+    runId: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<["queued", "running", "blocked", "succeeded", "no_op", "ungated", "review_not_run", "failed", "cancelled", "interrupted", "exhausted", "not_converged", "stuck_no_progress"]>;
+    runDir: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    failure: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        phase: z.ZodDefault<z.ZodString>;
+        category: z.ZodDefault<z.ZodEnum<["validation", "project", "auth", "harness_unavailable", "harness_error", "budget", "policy", "cancelled", "internal", "unknown"]>>;
+        harnessId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        attemptId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        safeMessage: z.ZodString;
+        rawDetailRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        logRefs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        eventRefs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        runDir: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        nextActions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        runDir: string | null;
+        category: "validation" | "unknown" | "harness_error" | "auth" | "cancelled" | "budget" | "project" | "policy" | "harness_unavailable" | "internal";
+        phase: string;
+        harnessId: string | null;
+        attemptId: string | null;
+        safeMessage: string;
+        rawDetailRef: string | null;
+        logRefs: string[];
+        eventRefs: string[];
+        nextActions: string[];
+    }, {
+        safeMessage: string;
+        runDir?: string | null | undefined;
+        category?: "validation" | "unknown" | "harness_error" | "auth" | "cancelled" | "budget" | "project" | "policy" | "harness_unavailable" | "internal" | undefined;
+        phase?: string | undefined;
+        harnessId?: string | null | undefined;
+        attemptId?: string | null | undefined;
+        rawDetailRef?: string | null | undefined;
+        logRefs?: string[] | undefined;
+        eventRefs?: string[] | undefined;
+        nextActions?: string[] | undefined;
+    }>>>;
+    project: z.ZodDefault<z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<["project", "none"]>>;
+        root: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        projectName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        context: z.ZodDefault<z.ZodEnum<["off", "auto"]>>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "none" | "project";
+        root: string | null;
+        context: "off" | "auto";
+        projectName: string | null;
+    }, {
+        kind?: "none" | "project" | undefined;
+        root?: string | null | undefined;
+        context?: "off" | "auto" | undefined;
+        projectName?: string | null | undefined;
+    }>>;
+    mode: z.ZodOptional<z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>>;
+    /** v0.9 engine strategy on the mode (flags, not modes): race width / repair caps / swarm / create. */
+    strategy: z.ZodOptional<z.ZodNullable<z.ZodEnum<["race", "attempts", "until_clean", "swarm", "create"]>>>;
+    prompt: z.ZodOptional<z.ZodString>;
+    harnesses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    primaryHarness: z.ZodOptional<z.ZodString>;
+    portfolio: z.ZodOptional<z.ZodEnum<["daily-rich", "balanced", "cheapest", "strongest", "burn", "subscription-first", "api-overflow", "conserve-claude", "conserve-codex"]>>;
+    model: z.ZodOptional<z.ZodString>;
+    reviewerPanel: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Explicit reviewer harness id. Repeated harness ids are allowed so one
+         * native provider can review through multiple requested models. */
+        harness: z.ZodString;
+        /** Optional per-reviewer model hint, passed to that harness only. */
+        model: z.ZodOptional<z.ZodString>;
+        /** Optional per-reviewer effort hint, passed to that harness only. */
+        effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
+    }, "strict", z.ZodTypeAny, {
+        harness: string;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+        model?: string | undefined;
+    }, {
+        harness: string;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+        model?: string | undefined;
+    }>, "many">>;
+    protectedPathApprovals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        reason?: string | undefined;
+    }, {
+        path: string;
+        reason?: string | undefined;
+    }>, "many">>;
+    n: z.ZodOptional<z.ZodNumber>;
+    maxUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    spendUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    spendEstimated: z.ZodOptional<z.ZodBoolean>;
+    access: z.ZodOptional<z.ZodEnum<["readonly", "workspace_write", "full", "external_sandbox_full", "inherit_native"]>>;
+    requestedAccess: z.ZodOptional<z.ZodEnum<["readonly", "workspace_write", "full", "external_sandbox_full", "inherit_native"]>>;
+    effectiveAccess: z.ZodOptional<z.ZodEnum<["readonly", "workspace_write", "full", "external_sandbox_full", "inherit_native"]>>;
+    externalContextPolicy: z.ZodOptional<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+    webRequired: z.ZodOptional<z.ZodBoolean>;
+    webMode: z.ZodOptional<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+    webEvidence: z.ZodDefault<z.ZodObject<{
+        required: z.ZodDefault<z.ZodBoolean>;
+        /** Requested external-context policy for the run. */
+        mode: z.ZodDefault<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+        /** Mode the selected route actually executed (disclosed upgrades, e.g. claude cached->live). */
+        effectiveMode: z.ZodDefault<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+        attempted: z.ZodDefault<z.ZodBoolean>;
+        satisfied: z.ZodDefault<z.ZodBoolean>;
+        status: z.ZodDefault<z.ZodEnum<["none", "attempted", "satisfied", "failed", "unverified"]>>;
+        tool: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        target: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        errorSummary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        rawDetailRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** False when the run predates telemetry.yaml; surfaces must render "telemetry unavailable". */
+        available: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        status: "none" | "failed" | "attempted" | "unverified" | "satisfied";
+        target: string | null;
+        tool: string | null;
+        mode: "off" | "auto" | "cached" | "live";
+        required: boolean;
+        attempted: boolean;
+        rawDetailRef: string | null;
+        effectiveMode: "off" | "auto" | "cached" | "live";
+        satisfied: boolean;
+        errorSummary: string | null;
+        available: boolean;
+    }, {
+        status?: "none" | "failed" | "attempted" | "unverified" | "satisfied" | undefined;
+        target?: string | null | undefined;
+        tool?: string | null | undefined;
+        mode?: "off" | "auto" | "cached" | "live" | undefined;
+        required?: boolean | undefined;
+        attempted?: boolean | undefined;
+        rawDetailRef?: string | null | undefined;
+        effectiveMode?: "off" | "auto" | "cached" | "live" | undefined;
+        satisfied?: boolean | undefined;
+        errorSummary?: string | null | undefined;
+        available?: boolean | undefined;
+    }>>;
+    toolPermissionPolicy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputReadyState: z.ZodDefault<z.ZodEnum<["pending", "finalizing", "ready", "diagnostic"]>>;
+    /** Non-blocking tool warnings projected from final/telemetry.yaml. */
+    toolWarningsTotal: z.ZodDefault<z.ZodNumber>;
+    /** Honest terminal outcome (what the turn did): patch/answer/plan/report/none. */
+    result: z.ZodDefault<z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<["patch", "answer", "plan", "report", "none"]>>;
+        diffStat: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            files: z.ZodNumber;
+            additions: z.ZodNumber;
+            deletions: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            files: number;
+            additions: number;
+            deletions: number;
+        }, {
+            files: number;
+            additions: number;
+            deletions: number;
+        }>>>;
+        blockers: z.ZodDefault<z.ZodNumber>;
+        /** True when the live in-place tree was mutated this turn (regardless of review). */
+        adopted: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+        /** Honest application state (decoupled from clean-terminal). */
+        applyState: z.ZodDefault<z.ZodEnum<["not_applied", "applied", "applied_review_blocked", "reverted"]>>;
+        /** Tree SHA before this turn mutated the in-place tree (revert restore target). */
+        preTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Tree SHA right after this turn's mutation (revert divergence fence: refuse
+         * to revert if the working tree has diverged from this since). */
+        postTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Revert metadata is available (the turn mutated the live tree in place and
+         * pre/post-turn snapshots were recorded), so a Revert affordance may be offered.
+         * This is NOT a live-safe guarantee: the server re-checks tree divergence at
+         * revert time and refuses (fail loud) if the working tree changed since. */
+        revertable: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "plan" | "none" | "patch" | "report" | "answer";
+        diffStat: {
+            files: number;
+            additions: number;
+            deletions: number;
+        } | null;
+        blockers: number;
+        adopted: boolean | null;
+        applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+        preTurnSha: string | null;
+        postTurnSha: string | null;
+        revertable: boolean;
+    }, {
+        kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+        diffStat?: {
+            files: number;
+            additions: number;
+            deletions: number;
+        } | null | undefined;
+        blockers?: number | undefined;
+        adopted?: boolean | null | undefined;
+        applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+        preTurnSha?: string | null | undefined;
+        postTurnSha?: string | null | undefined;
+        revertable?: boolean | undefined;
+    }>>;
+    /** True while at least one interaction.requested has no answered/timeout. */
+    waitingOnUser: z.ZodDefault<z.ZodBoolean>;
+    /** Route evidence from telemetry; null when no telemetry exists (legacy). */
+    route: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        requestedModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        observedModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        harnessId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        verified: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        verified: boolean;
+        harnessId: string | null;
+        requestedModel: string | null;
+        observedModel: string | null;
+    }, {
+        verified?: boolean | undefined;
+        harnessId?: string | null | undefined;
+        requestedModel?: string | null | undefined;
+        observedModel?: string | null | undefined;
+    }>>>;
+    tests: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    specId: z.ZodOptional<z.ZodString>;
+    specHash: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+    runId: string;
+    project: {
+        kind: "none" | "project";
+        root: string | null;
+        context: "off" | "auto";
+        projectName: string | null;
+    };
+    jobId: string;
+    failure: {
+        runDir: string | null;
+        category: "validation" | "unknown" | "harness_error" | "auth" | "cancelled" | "budget" | "project" | "policy" | "harness_unavailable" | "internal";
+        phase: string;
+        harnessId: string | null;
+        attemptId: string | null;
+        safeMessage: string;
+        rawDetailRef: string | null;
+        logRefs: string[];
+        eventRefs: string[];
+        nextActions: string[];
+    } | null;
+    webEvidence: {
+        status: "none" | "failed" | "attempted" | "unverified" | "satisfied";
+        target: string | null;
+        tool: string | null;
+        mode: "off" | "auto" | "cached" | "live";
+        required: boolean;
+        attempted: boolean;
+        rawDetailRef: string | null;
+        effectiveMode: "off" | "auto" | "cached" | "live";
+        satisfied: boolean;
+        errorSummary: string | null;
+        available: boolean;
+    };
+    outputReadyState: "pending" | "finalizing" | "ready" | "diagnostic";
+    toolWarningsTotal: number;
+    result: {
+        kind: "plan" | "none" | "patch" | "report" | "answer";
+        diffStat: {
+            files: number;
+            additions: number;
+            deletions: number;
+        } | null;
+        blockers: number;
+        adopted: boolean | null;
+        applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+        preTurnSha: string | null;
+        postTurnSha: string | null;
+        revertable: boolean;
+    };
+    waitingOnUser: boolean;
+    route: {
+        verified: boolean;
+        harnessId: string | null;
+        requestedModel: string | null;
+        observedModel: string | null;
+    } | null;
+    prompt?: string | undefined;
+    access?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    error?: string | undefined;
+    mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    harnesses?: string[] | undefined;
+    runDir?: string | undefined;
+    tests?: string[] | undefined;
+    portfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    n?: number | undefined;
+    model?: string | undefined;
+    primaryHarness?: string | undefined;
+    maxUsd?: number | null | undefined;
+    externalContextPolicy?: "off" | "auto" | "cached" | "live" | undefined;
+    protectedPathApprovals?: {
+        path: string;
+        reason?: string | undefined;
+    }[] | undefined;
+    specId?: string | undefined;
+    specHash?: string | undefined;
+    reviewerPanel?: {
+        harness: string;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+        model?: string | undefined;
+    }[] | undefined;
+    createdAt?: string | undefined;
+    startedAt?: string | undefined;
+    finishedAt?: string | undefined;
+    taskId?: string | undefined;
+    strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+    spendUsd?: number | null | undefined;
+    spendEstimated?: boolean | undefined;
+    requestedAccess?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    effectiveAccess?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    webRequired?: boolean | undefined;
+    webMode?: "off" | "auto" | "cached" | "live" | undefined;
+    toolPermissionPolicy?: Record<string, unknown> | undefined;
+}, {
+    state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+    runId: string;
+    jobId: string;
+    prompt?: string | undefined;
+    access?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    error?: string | undefined;
+    mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    harnesses?: string[] | undefined;
+    runDir?: string | undefined;
+    tests?: string[] | undefined;
+    portfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    project?: {
+        kind?: "none" | "project" | undefined;
+        root?: string | null | undefined;
+        context?: "off" | "auto" | undefined;
+        projectName?: string | null | undefined;
+    } | undefined;
+    n?: number | undefined;
+    model?: string | undefined;
+    primaryHarness?: string | undefined;
+    maxUsd?: number | null | undefined;
+    externalContextPolicy?: "off" | "auto" | "cached" | "live" | undefined;
+    protectedPathApprovals?: {
+        path: string;
+        reason?: string | undefined;
+    }[] | undefined;
+    specId?: string | undefined;
+    specHash?: string | undefined;
+    reviewerPanel?: {
+        harness: string;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+        model?: string | undefined;
+    }[] | undefined;
+    createdAt?: string | undefined;
+    startedAt?: string | undefined;
+    finishedAt?: string | undefined;
+    taskId?: string | undefined;
+    failure?: {
+        safeMessage: string;
+        runDir?: string | null | undefined;
+        category?: "validation" | "unknown" | "harness_error" | "auth" | "cancelled" | "budget" | "project" | "policy" | "harness_unavailable" | "internal" | undefined;
+        phase?: string | undefined;
+        harnessId?: string | null | undefined;
+        attemptId?: string | null | undefined;
+        rawDetailRef?: string | null | undefined;
+        logRefs?: string[] | undefined;
+        eventRefs?: string[] | undefined;
+        nextActions?: string[] | undefined;
+    } | null | undefined;
+    strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+    spendUsd?: number | null | undefined;
+    spendEstimated?: boolean | undefined;
+    requestedAccess?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    effectiveAccess?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    webRequired?: boolean | undefined;
+    webMode?: "off" | "auto" | "cached" | "live" | undefined;
+    webEvidence?: {
+        status?: "none" | "failed" | "attempted" | "unverified" | "satisfied" | undefined;
+        target?: string | null | undefined;
+        tool?: string | null | undefined;
+        mode?: "off" | "auto" | "cached" | "live" | undefined;
+        required?: boolean | undefined;
+        attempted?: boolean | undefined;
+        rawDetailRef?: string | null | undefined;
+        effectiveMode?: "off" | "auto" | "cached" | "live" | undefined;
+        satisfied?: boolean | undefined;
+        errorSummary?: string | null | undefined;
+        available?: boolean | undefined;
+    } | undefined;
+    toolPermissionPolicy?: Record<string, unknown> | undefined;
+    outputReadyState?: "pending" | "finalizing" | "ready" | "diagnostic" | undefined;
+    toolWarningsTotal?: number | undefined;
+    result?: {
+        kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+        diffStat?: {
+            files: number;
+            additions: number;
+            deletions: number;
+        } | null | undefined;
+        blockers?: number | undefined;
+        adopted?: boolean | null | undefined;
+        applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+        preTurnSha?: string | null | undefined;
+        postTurnSha?: string | null | undefined;
+        revertable?: boolean | undefined;
+    } | undefined;
+    waitingOnUser?: boolean | undefined;
+    route?: {
+        verified?: boolean | undefined;
+        harnessId?: string | null | undefined;
+        requestedModel?: string | null | undefined;
+        observedModel?: string | null | undefined;
+    } | null | undefined;
+}>;
+export type ControlRunSummary = z.infer<typeof ControlRunSummary>;
+export declare const ControlPrimaryOutput: z.ZodObject<{
+    kind: z.ZodEnum<["answer", "report", "plan", "summary", "patch", "diagnostic"]>;
+    path: z.ZodString;
+    text: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    bytes: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    kind: "diagnostic" | "plan" | "summary" | "patch" | "report" | "answer";
+    text: string | null;
+    bytes?: number | undefined;
+}, {
+    path: string;
+    kind: "diagnostic" | "plan" | "summary" | "patch" | "report" | "answer";
+    text?: string | null | undefined;
+    bytes?: number | undefined;
+}>;
+export type ControlPrimaryOutput = z.infer<typeof ControlPrimaryOutput>;
+export declare const ControlTimelineEvent: z.ZodObject<{
+    type: z.ZodString;
+    ts: z.ZodOptional<z.ZodString>;
+    harnessId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    attemptId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    title: z.ZodString;
+    detail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    severity: z.ZodDefault<z.ZodEnum<["info", "warning", "error"]>>;
+    toolName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    target: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    errorSummary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    rawRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    detail: string | null;
+    target: string | null;
+    title: string;
+    severity: "error" | "info" | "warning";
+    harnessId: string | null;
+    attemptId: string | null;
+    errorSummary: string | null;
+    toolName: string | null;
+    rawRef: string | null;
+    ts?: string | undefined;
+}, {
+    type: string;
+    title: string;
+    detail?: string | null | undefined;
+    target?: string | null | undefined;
+    ts?: string | undefined;
+    severity?: "error" | "info" | "warning" | undefined;
+    harnessId?: string | null | undefined;
+    attemptId?: string | null | undefined;
+    errorSummary?: string | null | undefined;
+    toolName?: string | null | undefined;
+    rawRef?: string | null | undefined;
+}>;
+export type ControlTimelineEvent = z.infer<typeof ControlTimelineEvent>;
+export declare const ControlBudgetSnapshot: z.ZodObject<{
+    maxUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    spendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    remainingUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    estimated: z.ZodDefault<z.ZodBoolean>;
+    source: z.ZodDefault<z.ZodEnum<["decision", "events", "settings", "unknown"]>>;
+}, "strip", z.ZodTypeAny, {
+    source: "unknown" | "decision" | "events" | "settings";
+    estimated: boolean;
+    maxUsd: number | null;
+    spendUsd: number | null;
+    remainingUsd: number | null;
+}, {
+    source?: "unknown" | "decision" | "events" | "settings" | undefined;
+    estimated?: boolean | undefined;
+    maxUsd?: number | null | undefined;
+    spendUsd?: number | null | undefined;
+    remainingUsd?: number | null | undefined;
+}>;
+export type ControlBudgetSnapshot = z.infer<typeof ControlBudgetSnapshot>;
+export declare const ControlArtifactInfo: z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodEnum<["file", "directory"]>;
+    bytes: z.ZodOptional<z.ZodNumber>;
+    /** Clean MIME type derived from the extension (e.g. `image/png`, `text/plain`,
+     *  `application/pdf`); lets a gallery render text vs image vs pdf. Absent for
+     *  directories. */
+    mime: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    kind: "file" | "directory";
+    mime?: string | undefined;
+    bytes?: number | undefined;
+}, {
+    path: string;
+    kind: "file" | "directory";
+    mime?: string | undefined;
+    bytes?: number | undefined;
+}>;
+export type ControlArtifactInfo = z.infer<typeof ControlArtifactInfo>;
+/** A live interaction awaiting the user's answer (snapshot projection). */
+export declare const ControlPendingInteraction: z.ZodObject<{
+    interactionId: z.ZodString;
+    runId: z.ZodString;
+    attemptId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    harnessId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    sourceTool: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    questions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        header: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            description: string | null;
+        }, {
+            label: string;
+            description?: string | null | undefined;
+        }>, "many">>;
+        multi_select: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        options: {
+            label: string;
+            description: string | null;
+        }[];
+        id: string;
+        question: string;
+        header: string | null;
+        multi_select: boolean;
+    }, {
+        id: string;
+        question: string;
+        options?: {
+            label: string;
+            description?: string | null | undefined;
+        }[] | undefined;
+        header?: string | null | undefined;
+        multi_select?: boolean | undefined;
+    }>, "many">>;
+    requestedAt: z.ZodString;
+    timeoutAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    questions: {
+        options: {
+            label: string;
+            description: string | null;
+        }[];
+        id: string;
+        question: string;
+        header: string | null;
+        multi_select: boolean;
+    }[];
+    runId: string;
+    harnessId: string | null;
+    attemptId: string | null;
+    interactionId: string;
+    sourceTool: string | null;
+    requestedAt: string;
+    timeoutAt: string | null;
+}, {
+    runId: string;
+    interactionId: string;
+    requestedAt: string;
+    questions?: {
+        id: string;
+        question: string;
+        options?: {
+            label: string;
+            description?: string | null | undefined;
+        }[] | undefined;
+        header?: string | null | undefined;
+        multi_select?: boolean | undefined;
+    }[] | undefined;
+    harnessId?: string | null | undefined;
+    attemptId?: string | null | undefined;
+    sourceTool?: string | null | undefined;
+    timeoutAt?: string | null | undefined;
+}>;
+export type ControlPendingInteraction = z.infer<typeof ControlPendingInteraction>;
+export declare const ControlInteractionAnswerRequest: z.ZodObject<{
+    answers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        selectedLabels: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        freeText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strict", z.ZodTypeAny, {
+        questionId: string;
+        selectedLabels: string[];
+        freeText: string | null;
+    }, {
+        questionId: string;
+        selectedLabels?: string[] | undefined;
+        freeText?: string | null | undefined;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    answers: {
+        questionId: string;
+        selectedLabels: string[];
+        freeText: string | null;
+    }[];
+}, {
+    answers?: {
+        questionId: string;
+        selectedLabels?: string[] | undefined;
+        freeText?: string | null | undefined;
+    }[] | undefined;
+}>;
+export type ControlInteractionAnswerRequest = z.infer<typeof ControlInteractionAnswerRequest>;
+export declare const ControlInteractionAnswerResponse: z.ZodObject<{
+    accepted: z.ZodBoolean;
+    status: z.ZodEnum<["delivered", "not_found", "already_resolved", "rejected"]>;
+    message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "delivered" | "not_found" | "already_resolved" | "rejected";
+    accepted: boolean;
+    message?: string | undefined;
+}, {
+    status: "delivered" | "not_found" | "already_resolved" | "rejected";
+    accepted: boolean;
+    message?: string | undefined;
+}>;
+export type ControlInteractionAnswerResponse = z.infer<typeof ControlInteractionAnswerResponse>;
+export declare const RunControlTarget: z.ZodObject<{
+    attemptId: z.ZodOptional<z.ZodString>;
+    harnessId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    harnessId?: string | undefined;
+    attemptId?: string | undefined;
+    sessionId?: string | undefined;
+    requestId?: string | undefined;
+}, {
+    harnessId?: string | undefined;
+    attemptId?: string | undefined;
+    sessionId?: string | undefined;
+    requestId?: string | undefined;
+}>;
+export type RunControlTarget = z.infer<typeof RunControlTarget>;
+export declare const RunControl: z.ZodObject<{
+    kind: z.ZodEnum<["cancel"]>;
+    target: z.ZodDefault<z.ZodObject<{
+        attemptId: z.ZodOptional<z.ZodString>;
+        harnessId: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        harnessId?: string | undefined;
+        attemptId?: string | undefined;
+        sessionId?: string | undefined;
+        requestId?: string | undefined;
+    }, {
+        harnessId?: string | undefined;
+        attemptId?: string | undefined;
+        sessionId?: string | undefined;
+        requestId?: string | undefined;
+    }>>;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "cancel";
+    target: {
+        harnessId?: string | undefined;
+        attemptId?: string | undefined;
+        sessionId?: string | undefined;
+        requestId?: string | undefined;
+    };
+    reason?: string | undefined;
+}, {
+    kind: "cancel";
+    target?: {
+        harnessId?: string | undefined;
+        attemptId?: string | undefined;
+        sessionId?: string | undefined;
+        requestId?: string | undefined;
+    } | undefined;
+    reason?: string | undefined;
+}>;
+export type RunControl = z.infer<typeof RunControl>;
+export declare const ControlRunControlRequest: z.ZodObject<{
+    control: z.ZodObject<{
+        kind: z.ZodEnum<["cancel"]>;
+        target: z.ZodDefault<z.ZodObject<{
+            attemptId: z.ZodOptional<z.ZodString>;
+            harnessId: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            requestId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            harnessId?: string | undefined;
+            attemptId?: string | undefined;
+            sessionId?: string | undefined;
+            requestId?: string | undefined;
+        }, {
+            harnessId?: string | undefined;
+            attemptId?: string | undefined;
+            sessionId?: string | undefined;
+            requestId?: string | undefined;
+        }>>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "cancel";
+        target: {
+            harnessId?: string | undefined;
+            attemptId?: string | undefined;
+            sessionId?: string | undefined;
+            requestId?: string | undefined;
+        };
+        reason?: string | undefined;
+    }, {
+        kind: "cancel";
+        target?: {
+            harnessId?: string | undefined;
+            attemptId?: string | undefined;
+            sessionId?: string | undefined;
+            requestId?: string | undefined;
+        } | undefined;
+        reason?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    control: {
+        kind: "cancel";
+        target: {
+            harnessId?: string | undefined;
+            attemptId?: string | undefined;
+            sessionId?: string | undefined;
+            requestId?: string | undefined;
+        };
+        reason?: string | undefined;
+    };
+}, {
+    control: {
+        kind: "cancel";
+        target?: {
+            harnessId?: string | undefined;
+            attemptId?: string | undefined;
+            sessionId?: string | undefined;
+            requestId?: string | undefined;
+        } | undefined;
+        reason?: string | undefined;
+    };
+}>;
+export type ControlRunControlRequest = z.infer<typeof ControlRunControlRequest>;
+export declare const ControlRunControlResponse: z.ZodObject<{
+    accepted: z.ZodBoolean;
+    status: z.ZodDefault<z.ZodEnum<["applied", "queued", "rejected", "unsupported"]>>;
+    runId: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "queued" | "applied" | "rejected" | "unsupported";
+    accepted: boolean;
+    message?: string | undefined;
+    runId?: string | undefined;
+}, {
+    accepted: boolean;
+    message?: string | undefined;
+    status?: "queued" | "applied" | "rejected" | "unsupported" | undefined;
+    runId?: string | undefined;
+}>;
+export type ControlRunControlResponse = z.infer<typeof ControlRunControlResponse>;
+export declare const ApplyTarget: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"original_project">;
+}, "strict", z.ZodTypeAny, {
+    kind: "original_project";
+}, {
+    kind: "original_project";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"project">;
+    root: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "project";
+    root: string;
+}, {
+    kind: "project";
+    root: string;
+}>]>;
+export type ApplyTarget = z.infer<typeof ApplyTarget>;
+export declare const ControlApplyCheckRequest: z.ZodObject<{
+    target: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"original_project">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "original_project";
+    }, {
+        kind: "original_project";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        root: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "project";
+        root: string;
+    }, {
+        kind: "project";
+        root: string;
+    }>]>>;
+}, "strict", z.ZodTypeAny, {
+    target: {
+        kind: "original_project";
+    } | {
+        kind: "project";
+        root: string;
+    };
+}, {
+    target?: {
+        kind: "original_project";
+    } | {
+        kind: "project";
+        root: string;
+    } | undefined;
+}>;
+export type ControlApplyCheckRequest = z.infer<typeof ControlApplyCheckRequest>;
+export declare const ControlApplyRequest: z.ZodObject<{
+    target: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"original_project">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "original_project";
+    }, {
+        kind: "original_project";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        root: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "project";
+        root: string;
+    }, {
+        kind: "project";
+        root: string;
+    }>]>>;
+    mode: z.ZodDefault<z.ZodEnum<["artifact_only", "apply", "branch", "commit", "pr"]>>;
+    branch: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    target: {
+        kind: "original_project";
+    } | {
+        kind: "project";
+        root: string;
+    };
+    mode: "apply" | "commit" | "branch" | "pr" | "artifact_only";
+    message?: string | undefined;
+    branch?: string | undefined;
+}, {
+    message?: string | undefined;
+    target?: {
+        kind: "original_project";
+    } | {
+        kind: "project";
+        root: string;
+    } | undefined;
+    mode?: "apply" | "commit" | "branch" | "pr" | "artifact_only" | undefined;
+    branch?: string | undefined;
+}>;
+export type ControlApplyRequest = z.infer<typeof ControlApplyRequest>;
+/**
+ * Operator decision on a NEEDS_HUMAN-blocked run (review_actions). Closes the
+ * v0.8 "apply: human_review" dead end: a typed, auditable unblock path instead
+ * of a read-only review queue.
+ */
+export declare const RunDecisionAction: z.ZodEnum<["accept_clean_patch", "rerun_with_feedback", "accept_risk", "override_needs_human", "revert_run"]>;
+export type RunDecisionAction = z.infer<typeof RunDecisionAction>;
+export declare const ControlRunDecisionRequest: z.ZodObject<{
+    action: z.ZodEnum<["accept_clean_patch", "rerun_with_feedback", "accept_risk", "override_needs_human", "revert_run"]>;
+    /** Findings the decision targets (override/accept_risk). */
+    findingIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Reviewer feedback to seed a rerun turn. */
+    feedback: z.ZodOptional<z.ZodString>;
+    /** Risk reasons being explicitly accepted (recorded, never silent). */
+    acceptedRisks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Apply mode + target for accept_clean_patch. */
+    applyMode: z.ZodOptional<z.ZodEnum<["artifact_only", "apply", "branch", "commit", "pr"]>>;
+    target: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"original_project">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "original_project";
+    }, {
+        kind: "original_project";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        root: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "project";
+        root: string;
+    }, {
+        kind: "project";
+        root: string;
+    }>]>>;
+}, "strict", z.ZodTypeAny, {
+    action: "accept_clean_patch" | "rerun_with_feedback" | "accept_risk" | "override_needs_human" | "revert_run";
+    findingIds: string[];
+    acceptedRisks: string[];
+    target?: {
+        kind: "original_project";
+    } | {
+        kind: "project";
+        root: string;
+    } | undefined;
+    feedback?: string | undefined;
+    applyMode?: "apply" | "commit" | "branch" | "pr" | "artifact_only" | undefined;
+}, {
+    action: "accept_clean_patch" | "rerun_with_feedback" | "accept_risk" | "override_needs_human" | "revert_run";
+    target?: {
+        kind: "original_project";
+    } | {
+        kind: "project";
+        root: string;
+    } | undefined;
+    findingIds?: string[] | undefined;
+    feedback?: string | undefined;
+    acceptedRisks?: string[] | undefined;
+    applyMode?: "apply" | "commit" | "branch" | "pr" | "artifact_only" | undefined;
+}>;
+export type ControlRunDecisionRequest = z.infer<typeof ControlRunDecisionRequest>;
+export declare const ControlRunDecisionResponse: z.ZodObject<{
+    accepted: z.ZodBoolean;
+    status: z.ZodEnum<["applied", "requeued", "rejected", "unsupported"]>;
+    /** New run id when the decision re-enqueues a turn (rerun_with_feedback). */
+    newRunId: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "applied" | "rejected" | "unsupported" | "requeued";
+    accepted: boolean;
+    message?: string | undefined;
+    newRunId?: string | undefined;
+}, {
+    status: "applied" | "rejected" | "unsupported" | "requeued";
+    accepted: boolean;
+    message?: string | undefined;
+    newRunId?: string | undefined;
+}>;
+export type ControlRunDecisionResponse = z.infer<typeof ControlRunDecisionResponse>;
+export declare const ControlThread: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    repoRoot: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    mode: z.ZodOptional<z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>>;
+    /** How turns touch files (in-place live tree vs isolated worktree). */
+    workspaceMode: z.ZodDefault<z.ZodEnum<["in_place", "isolated"]>>;
+    authPreference: z.ZodDefault<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+    primaryHarness: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Sticky eligible pool for the thread (empty => engine auto-pools). */
+    eligibleHarnesses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    state: z.ZodDefault<z.ZodEnum<["active", "closed"]>>;
+    runIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    headRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** True when the head turn is blocked on a human decision (needs-me inbox). */
+    needsHuman: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string | null;
+    state: "active" | "closed";
+    primaryHarness: string | null;
+    authPreference: "auto" | "subscription" | "api_key";
+    createdAt: string;
+    repoRoot: string | null;
+    workspaceMode: "in_place" | "isolated";
+    eligibleHarnesses: string[];
+    runIds: string[];
+    headRunId: string | null;
+    needsHuman: boolean;
+    updatedAt: string;
+    mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+}, {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    title?: string | null | undefined;
+    mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    state?: "active" | "closed" | undefined;
+    primaryHarness?: string | null | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    repoRoot?: string | null | undefined;
+    workspaceMode?: "in_place" | "isolated" | undefined;
+    eligibleHarnesses?: string[] | undefined;
+    runIds?: string[] | undefined;
+    headRunId?: string | null | undefined;
+    needsHuman?: boolean | undefined;
+}>;
+export type ControlThread = z.infer<typeof ControlThread>;
+export declare const ControlSession: z.ZodObject<{
+    id: z.ZodString;
+    threadId: z.ZodString;
+    harnessId: z.ZodString;
+    nativeSessionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    observedModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    state: z.ZodDefault<z.ZodEnum<["live", "stale", "rebound"]>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    state: "live" | "stale" | "rebound";
+    threadId: string;
+    harnessId: string;
+    observedModel: string | null;
+    nativeSessionId: string | null;
+}, {
+    id: string;
+    threadId: string;
+    harnessId: string;
+    state?: "live" | "stale" | "rebound" | undefined;
+    observedModel?: string | null | undefined;
+    nativeSessionId?: string | null | undefined;
+}>;
+export type ControlSession = z.infer<typeof ControlSession>;
+/**
+ * Compact run state embedded on a turn so a chat surface renders the whole
+ * conversation from one GET /threads/:id (no N+1 run-detail fetch per turn).
+ */
+export declare const ControlTurnRunCard: z.ZodObject<{
+    state: z.ZodEnum<["queued", "running", "blocked", "succeeded", "no_op", "ungated", "review_not_run", "failed", "cancelled", "interrupted", "exhausted", "not_converged", "stuck_no_progress"]>;
+    mode: z.ZodOptional<z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>>;
+    strategy: z.ZodOptional<z.ZodNullable<z.ZodEnum<["race", "attempts", "until_clean", "swarm", "create"]>>>;
+    n: z.ZodOptional<z.ZodNumber>;
+    result: z.ZodDefault<z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<["patch", "answer", "plan", "report", "none"]>>;
+        diffStat: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            files: z.ZodNumber;
+            additions: z.ZodNumber;
+            deletions: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            files: number;
+            additions: number;
+            deletions: number;
+        }, {
+            files: number;
+            additions: number;
+            deletions: number;
+        }>>>;
+        blockers: z.ZodDefault<z.ZodNumber>;
+        /** True when the live in-place tree was mutated this turn (regardless of review). */
+        adopted: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+        /** Honest application state (decoupled from clean-terminal). */
+        applyState: z.ZodDefault<z.ZodEnum<["not_applied", "applied", "applied_review_blocked", "reverted"]>>;
+        /** Tree SHA before this turn mutated the in-place tree (revert restore target). */
+        preTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Tree SHA right after this turn's mutation (revert divergence fence: refuse
+         * to revert if the working tree has diverged from this since). */
+        postTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Revert metadata is available (the turn mutated the live tree in place and
+         * pre/post-turn snapshots were recorded), so a Revert affordance may be offered.
+         * This is NOT a live-safe guarantee: the server re-checks tree divergence at
+         * revert time and refuses (fail loud) if the working tree changed since. */
+        revertable: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "plan" | "none" | "patch" | "report" | "answer";
+        diffStat: {
+            files: number;
+            additions: number;
+            deletions: number;
+        } | null;
+        blockers: number;
+        adopted: boolean | null;
+        applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+        preTurnSha: string | null;
+        postTurnSha: string | null;
+        revertable: boolean;
+    }, {
+        kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+        diffStat?: {
+            files: number;
+            additions: number;
+            deletions: number;
+        } | null | undefined;
+        blockers?: number | undefined;
+        adopted?: boolean | null | undefined;
+        applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+        preTurnSha?: string | null | undefined;
+        postTurnSha?: string | null | undefined;
+        revertable?: boolean | undefined;
+    }>>;
+    spendUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    outputReadyState: z.ZodDefault<z.ZodEnum<["pending", "finalizing", "ready", "diagnostic"]>>;
+    waitingOnUser: z.ZodDefault<z.ZodBoolean>;
+    finishedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+    finishedAt: string | null;
+    outputReadyState: "pending" | "finalizing" | "ready" | "diagnostic";
+    result: {
+        kind: "plan" | "none" | "patch" | "report" | "answer";
+        diffStat: {
+            files: number;
+            additions: number;
+            deletions: number;
+        } | null;
+        blockers: number;
+        adopted: boolean | null;
+        applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+        preTurnSha: string | null;
+        postTurnSha: string | null;
+        revertable: boolean;
+    };
+    waitingOnUser: boolean;
+    mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    n?: number | undefined;
+    strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+    spendUsd?: number | null | undefined;
+}, {
+    state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+    mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    n?: number | undefined;
+    finishedAt?: string | null | undefined;
+    strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+    spendUsd?: number | null | undefined;
+    outputReadyState?: "pending" | "finalizing" | "ready" | "diagnostic" | undefined;
+    result?: {
+        kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+        diffStat?: {
+            files: number;
+            additions: number;
+            deletions: number;
+        } | null | undefined;
+        blockers?: number | undefined;
+        adopted?: boolean | null | undefined;
+        applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+        preTurnSha?: string | null | undefined;
+        postTurnSha?: string | null | undefined;
+        revertable?: boolean | undefined;
+    } | undefined;
+    waitingOnUser?: boolean | undefined;
+}>;
+export type ControlTurnRunCard = z.infer<typeof ControlTurnRunCard>;
+export declare const ControlThreadTurn: z.ZodObject<{
+    id: z.ZodString;
+    threadId: z.ZodString;
+    runId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    parentRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Set when this turn implements an approved plan from an earlier run. */
+    planRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodDefault<z.ZodEnum<["initial", "followup", "decision"]>>;
+    prompt: z.ZodDefault<z.ZodString>;
+    /** Embedded run card (outcome/state) so the chat renders without N+1 fetches. */
+    run: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        state: z.ZodEnum<["queued", "running", "blocked", "succeeded", "no_op", "ungated", "review_not_run", "failed", "cancelled", "interrupted", "exhausted", "not_converged", "stuck_no_progress"]>;
+        mode: z.ZodOptional<z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>>;
+        strategy: z.ZodOptional<z.ZodNullable<z.ZodEnum<["race", "attempts", "until_clean", "swarm", "create"]>>>;
+        n: z.ZodOptional<z.ZodNumber>;
+        result: z.ZodDefault<z.ZodObject<{
+            kind: z.ZodDefault<z.ZodEnum<["patch", "answer", "plan", "report", "none"]>>;
+            diffStat: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                files: z.ZodNumber;
+                additions: z.ZodNumber;
+                deletions: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                files: number;
+                additions: number;
+                deletions: number;
+            }, {
+                files: number;
+                additions: number;
+                deletions: number;
+            }>>>;
+            blockers: z.ZodDefault<z.ZodNumber>;
+            /** True when the live in-place tree was mutated this turn (regardless of review). */
+            adopted: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+            /** Honest application state (decoupled from clean-terminal). */
+            applyState: z.ZodDefault<z.ZodEnum<["not_applied", "applied", "applied_review_blocked", "reverted"]>>;
+            /** Tree SHA before this turn mutated the in-place tree (revert restore target). */
+            preTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            /** Tree SHA right after this turn's mutation (revert divergence fence: refuse
+             * to revert if the working tree has diverged from this since). */
+            postTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            /** Revert metadata is available (the turn mutated the live tree in place and
+             * pre/post-turn snapshots were recorded), so a Revert affordance may be offered.
+             * This is NOT a live-safe guarantee: the server re-checks tree divergence at
+             * revert time and refuses (fail loud) if the working tree changed since. */
+            revertable: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "plan" | "none" | "patch" | "report" | "answer";
+            diffStat: {
+                files: number;
+                additions: number;
+                deletions: number;
+            } | null;
+            blockers: number;
+            adopted: boolean | null;
+            applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+            preTurnSha: string | null;
+            postTurnSha: string | null;
+            revertable: boolean;
+        }, {
+            kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+            diffStat?: {
+                files: number;
+                additions: number;
+                deletions: number;
+            } | null | undefined;
+            blockers?: number | undefined;
+            adopted?: boolean | null | undefined;
+            applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+            preTurnSha?: string | null | undefined;
+            postTurnSha?: string | null | undefined;
+            revertable?: boolean | undefined;
+        }>>;
+        spendUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        outputReadyState: z.ZodDefault<z.ZodEnum<["pending", "finalizing", "ready", "diagnostic"]>>;
+        waitingOnUser: z.ZodDefault<z.ZodBoolean>;
+        finishedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+        finishedAt: string | null;
+        outputReadyState: "pending" | "finalizing" | "ready" | "diagnostic";
+        result: {
+            kind: "plan" | "none" | "patch" | "report" | "answer";
+            diffStat: {
+                files: number;
+                additions: number;
+                deletions: number;
+            } | null;
+            blockers: number;
+            adopted: boolean | null;
+            applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+            preTurnSha: string | null;
+            postTurnSha: string | null;
+            revertable: boolean;
+        };
+        waitingOnUser: boolean;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+        n?: number | undefined;
+        strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+        spendUsd?: number | null | undefined;
+    }, {
+        state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+        n?: number | undefined;
+        finishedAt?: string | null | undefined;
+        strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+        spendUsd?: number | null | undefined;
+        outputReadyState?: "pending" | "finalizing" | "ready" | "diagnostic" | undefined;
+        result?: {
+            kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+            diffStat?: {
+                files: number;
+                additions: number;
+                deletions: number;
+            } | null | undefined;
+            blockers?: number | undefined;
+            adopted?: boolean | null | undefined;
+            applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+            preTurnSha?: string | null | undefined;
+            postTurnSha?: string | null | undefined;
+            revertable?: boolean | undefined;
+        } | undefined;
+        waitingOnUser?: boolean | undefined;
+    }>>>;
+    /** Why this turn has NO run (enqueue/preflight refusal, e.g. the trust
+     * gate) — surfaces render it as an inline failure card with the remedy;
+     * null once a run binds (retry clears it). `code` is the typed throw's
+     * machine code (remedies key on it, never on the message text);
+     * `retryable=false` means no recorded job exists to replay — surfaces
+     * offer "send a new message" instead of a doomed Retry. */
+    enqueueError: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        retryable: z.ZodDefault<z.ZodBoolean>;
+        failedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string | null;
+        message: string;
+        retryable: boolean;
+        failedAt: string;
+    }, {
+        message: string;
+        failedAt: string;
+        code?: string | null | undefined;
+        retryable?: boolean | undefined;
+    }>>>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "initial" | "followup" | "decision";
+    prompt: string;
+    planRunId: string | null;
+    runId: string | null;
+    threadId: string;
+    parentRunId: string | null;
+    createdAt: string;
+    run: {
+        state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+        finishedAt: string | null;
+        outputReadyState: "pending" | "finalizing" | "ready" | "diagnostic";
+        result: {
+            kind: "plan" | "none" | "patch" | "report" | "answer";
+            diffStat: {
+                files: number;
+                additions: number;
+                deletions: number;
+            } | null;
+            blockers: number;
+            adopted: boolean | null;
+            applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+            preTurnSha: string | null;
+            postTurnSha: string | null;
+            revertable: boolean;
+        };
+        waitingOnUser: boolean;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+        n?: number | undefined;
+        strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+        spendUsd?: number | null | undefined;
+    } | null;
+    enqueueError: {
+        code: string | null;
+        message: string;
+        retryable: boolean;
+        failedAt: string;
+    } | null;
+}, {
+    id: string;
+    threadId: string;
+    createdAt: string;
+    kind?: "initial" | "followup" | "decision" | undefined;
+    prompt?: string | undefined;
+    planRunId?: string | null | undefined;
+    runId?: string | null | undefined;
+    parentRunId?: string | null | undefined;
+    run?: {
+        state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+        n?: number | undefined;
+        finishedAt?: string | null | undefined;
+        strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+        spendUsd?: number | null | undefined;
+        outputReadyState?: "pending" | "finalizing" | "ready" | "diagnostic" | undefined;
+        result?: {
+            kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+            diffStat?: {
+                files: number;
+                additions: number;
+                deletions: number;
+            } | null | undefined;
+            blockers?: number | undefined;
+            adopted?: boolean | null | undefined;
+            applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+            preTurnSha?: string | null | undefined;
+            postTurnSha?: string | null | undefined;
+            revertable?: boolean | undefined;
+        } | undefined;
+        waitingOnUser?: boolean | undefined;
+    } | null | undefined;
+    enqueueError?: {
+        message: string;
+        failedAt: string;
+        code?: string | null | undefined;
+        retryable?: boolean | undefined;
+    } | null | undefined;
+}>;
+export type ControlThreadTurn = z.infer<typeof ControlThreadTurn>;
+export declare const ControlThreadCreateRequest: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    scope: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"project">;
+        root: z.ZodString;
+        context: z.ZodDefault<z.ZodEnum<["auto"]>>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "project";
+        root: string;
+        context: "auto";
+    }, {
+        kind: "project";
+        root: string;
+        context?: "auto" | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"none">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "none";
+    }, {
+        kind: "none";
+    }>]>>;
+    mode: z.ZodOptional<z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>>;
+    workspace: z.ZodOptional<z.ZodEnum<["in_place", "isolated"]>>;
+    authPreference: z.ZodOptional<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+    primaryHarness: z.ZodOptional<z.ZodString>;
+    /** Sticky eligible pool for the thread; turns inherit it when unset. */
+    eligibleHarnesses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    scope: {
+        kind: "project";
+        root: string;
+        context: "auto";
+    } | {
+        kind: "none";
+    };
+    title?: string | undefined;
+    mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    workspace?: "in_place" | "isolated" | undefined;
+    primaryHarness?: string | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    eligibleHarnesses?: string[] | undefined;
+}, {
+    title?: string | undefined;
+    mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    workspace?: "in_place" | "isolated" | undefined;
+    scope?: {
+        kind: "project";
+        root: string;
+        context?: "auto" | undefined;
+    } | {
+        kind: "none";
+    } | undefined;
+    primaryHarness?: string | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    eligibleHarnesses?: string[] | undefined;
+}>;
+export type ControlThreadCreateRequest = z.infer<typeof ControlThreadCreateRequest>;
+/** Mutate a thread's title, open/closed state, or sticky routing (rename,
+ * archive, switch primary/pool). primaryHarness nullable => clear back to auto. */
+export declare const ControlThreadUpdateRequest: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodEnum<["active", "closed"]>>;
+    primaryHarness: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    eligibleHarnesses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    title?: string | undefined;
+    state?: "active" | "closed" | undefined;
+    primaryHarness?: string | null | undefined;
+    eligibleHarnesses?: string[] | undefined;
+}, {
+    title?: string | undefined;
+    state?: "active" | "closed" | undefined;
+    primaryHarness?: string | null | undefined;
+    eligibleHarnesses?: string[] | undefined;
+}>;
+export type ControlThreadUpdateRequest = z.infer<typeof ControlThreadUpdateRequest>;
+/** Apply an isolated thread's accumulated worktree diff to the project. */
+export declare const ControlThreadApplyRequest: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<["apply", "branch", "commit", "pr"]>>;
+    branch: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    mode: "apply" | "commit" | "branch" | "pr";
+    message?: string | undefined;
+    branch?: string | undefined;
+}, {
+    message?: string | undefined;
+    mode?: "apply" | "commit" | "branch" | "pr" | undefined;
+    branch?: string | undefined;
+}>;
+export type ControlThreadApplyRequest = z.infer<typeof ControlThreadApplyRequest>;
+export declare const ControlThreadApplyResponse: z.ZodObject<{
+    applied: z.ZodBoolean;
+    status: z.ZodEnum<["applied", "branched", "committed", "pr_opened", "empty", "conflict", "rejected"]>;
+    /** True when the project HEAD moved past the thread base since the thread started. */
+    headMoved: z.ZodDefault<z.ZodBoolean>;
+    detail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    status: "applied" | "rejected" | "branched" | "committed" | "pr_opened" | "empty" | "conflict";
+    detail: string | null;
+    applied: boolean;
+    headMoved: boolean;
+}, {
+    status: "applied" | "rejected" | "branched" | "committed" | "pr_opened" | "empty" | "conflict";
+    applied: boolean;
+    detail?: string | null | undefined;
+    headMoved?: boolean | undefined;
+}>;
+export type ControlThreadApplyResponse = z.infer<typeof ControlThreadApplyResponse>;
+export declare const ControlThreadListResponse: z.ZodObject<{
+    threads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        repoRoot: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        mode: z.ZodOptional<z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>>;
+        /** How turns touch files (in-place live tree vs isolated worktree). */
+        workspaceMode: z.ZodDefault<z.ZodEnum<["in_place", "isolated"]>>;
+        authPreference: z.ZodDefault<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+        primaryHarness: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Sticky eligible pool for the thread (empty => engine auto-pools). */
+        eligibleHarnesses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        state: z.ZodDefault<z.ZodEnum<["active", "closed"]>>;
+        runIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        headRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** True when the head turn is blocked on a human decision (needs-me inbox). */
+        needsHuman: z.ZodDefault<z.ZodBoolean>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string | null;
+        state: "active" | "closed";
+        primaryHarness: string | null;
+        authPreference: "auto" | "subscription" | "api_key";
+        createdAt: string;
+        repoRoot: string | null;
+        workspaceMode: "in_place" | "isolated";
+        eligibleHarnesses: string[];
+        runIds: string[];
+        headRunId: string | null;
+        needsHuman: boolean;
+        updatedAt: string;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    }, {
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        title?: string | null | undefined;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+        state?: "active" | "closed" | undefined;
+        primaryHarness?: string | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        repoRoot?: string | null | undefined;
+        workspaceMode?: "in_place" | "isolated" | undefined;
+        eligibleHarnesses?: string[] | undefined;
+        runIds?: string[] | undefined;
+        headRunId?: string | null | undefined;
+        needsHuman?: boolean | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    threads: {
+        id: string;
+        title: string | null;
+        state: "active" | "closed";
+        primaryHarness: string | null;
+        authPreference: "auto" | "subscription" | "api_key";
+        createdAt: string;
+        repoRoot: string | null;
+        workspaceMode: "in_place" | "isolated";
+        eligibleHarnesses: string[];
+        runIds: string[];
+        headRunId: string | null;
+        needsHuman: boolean;
+        updatedAt: string;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    }[];
+}, {
+    threads?: {
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        title?: string | null | undefined;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+        state?: "active" | "closed" | undefined;
+        primaryHarness?: string | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        repoRoot?: string | null | undefined;
+        workspaceMode?: "in_place" | "isolated" | undefined;
+        eligibleHarnesses?: string[] | undefined;
+        runIds?: string[] | undefined;
+        headRunId?: string | null | undefined;
+        needsHuman?: boolean | undefined;
+    }[] | undefined;
+}>;
+export type ControlThreadListResponse = z.infer<typeof ControlThreadListResponse>;
+export declare const ControlThreadDetail: z.ZodObject<{
+    thread: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        repoRoot: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        mode: z.ZodOptional<z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>>;
+        /** How turns touch files (in-place live tree vs isolated worktree). */
+        workspaceMode: z.ZodDefault<z.ZodEnum<["in_place", "isolated"]>>;
+        authPreference: z.ZodDefault<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+        primaryHarness: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Sticky eligible pool for the thread (empty => engine auto-pools). */
+        eligibleHarnesses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        state: z.ZodDefault<z.ZodEnum<["active", "closed"]>>;
+        runIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        headRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** True when the head turn is blocked on a human decision (needs-me inbox). */
+        needsHuman: z.ZodDefault<z.ZodBoolean>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string | null;
+        state: "active" | "closed";
+        primaryHarness: string | null;
+        authPreference: "auto" | "subscription" | "api_key";
+        createdAt: string;
+        repoRoot: string | null;
+        workspaceMode: "in_place" | "isolated";
+        eligibleHarnesses: string[];
+        runIds: string[];
+        headRunId: string | null;
+        needsHuman: boolean;
+        updatedAt: string;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    }, {
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        title?: string | null | undefined;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+        state?: "active" | "closed" | undefined;
+        primaryHarness?: string | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        repoRoot?: string | null | undefined;
+        workspaceMode?: "in_place" | "isolated" | undefined;
+        eligibleHarnesses?: string[] | undefined;
+        runIds?: string[] | undefined;
+        headRunId?: string | null | undefined;
+        needsHuman?: boolean | undefined;
+    }>;
+    sessions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        threadId: z.ZodString;
+        harnessId: z.ZodString;
+        nativeSessionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        observedModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        state: z.ZodDefault<z.ZodEnum<["live", "stale", "rebound"]>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        state: "live" | "stale" | "rebound";
+        threadId: string;
+        harnessId: string;
+        observedModel: string | null;
+        nativeSessionId: string | null;
+    }, {
+        id: string;
+        threadId: string;
+        harnessId: string;
+        state?: "live" | "stale" | "rebound" | undefined;
+        observedModel?: string | null | undefined;
+        nativeSessionId?: string | null | undefined;
+    }>, "many">>;
+    turns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        threadId: z.ZodString;
+        runId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        parentRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Set when this turn implements an approved plan from an earlier run. */
+        planRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        kind: z.ZodDefault<z.ZodEnum<["initial", "followup", "decision"]>>;
+        prompt: z.ZodDefault<z.ZodString>;
+        /** Embedded run card (outcome/state) so the chat renders without N+1 fetches. */
+        run: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            state: z.ZodEnum<["queued", "running", "blocked", "succeeded", "no_op", "ungated", "review_not_run", "failed", "cancelled", "interrupted", "exhausted", "not_converged", "stuck_no_progress"]>;
+            mode: z.ZodOptional<z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>>;
+            strategy: z.ZodOptional<z.ZodNullable<z.ZodEnum<["race", "attempts", "until_clean", "swarm", "create"]>>>;
+            n: z.ZodOptional<z.ZodNumber>;
+            result: z.ZodDefault<z.ZodObject<{
+                kind: z.ZodDefault<z.ZodEnum<["patch", "answer", "plan", "report", "none"]>>;
+                diffStat: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    files: z.ZodNumber;
+                    additions: z.ZodNumber;
+                    deletions: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                }, {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                }>>>;
+                blockers: z.ZodDefault<z.ZodNumber>;
+                /** True when the live in-place tree was mutated this turn (regardless of review). */
+                adopted: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+                /** Honest application state (decoupled from clean-terminal). */
+                applyState: z.ZodDefault<z.ZodEnum<["not_applied", "applied", "applied_review_blocked", "reverted"]>>;
+                /** Tree SHA before this turn mutated the in-place tree (revert restore target). */
+                preTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                /** Tree SHA right after this turn's mutation (revert divergence fence: refuse
+                 * to revert if the working tree has diverged from this since). */
+                postTurnSha: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                /** Revert metadata is available (the turn mutated the live tree in place and
+                 * pre/post-turn snapshots were recorded), so a Revert affordance may be offered.
+                 * This is NOT a live-safe guarantee: the server re-checks tree divergence at
+                 * revert time and refuses (fail loud) if the working tree changed since. */
+                revertable: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                kind: "plan" | "none" | "patch" | "report" | "answer";
+                diffStat: {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                } | null;
+                blockers: number;
+                adopted: boolean | null;
+                applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+                preTurnSha: string | null;
+                postTurnSha: string | null;
+                revertable: boolean;
+            }, {
+                kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+                diffStat?: {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                } | null | undefined;
+                blockers?: number | undefined;
+                adopted?: boolean | null | undefined;
+                applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+                preTurnSha?: string | null | undefined;
+                postTurnSha?: string | null | undefined;
+                revertable?: boolean | undefined;
+            }>>;
+            spendUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            outputReadyState: z.ZodDefault<z.ZodEnum<["pending", "finalizing", "ready", "diagnostic"]>>;
+            waitingOnUser: z.ZodDefault<z.ZodBoolean>;
+            finishedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+            finishedAt: string | null;
+            outputReadyState: "pending" | "finalizing" | "ready" | "diagnostic";
+            result: {
+                kind: "plan" | "none" | "patch" | "report" | "answer";
+                diffStat: {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                } | null;
+                blockers: number;
+                adopted: boolean | null;
+                applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+                preTurnSha: string | null;
+                postTurnSha: string | null;
+                revertable: boolean;
+            };
+            waitingOnUser: boolean;
+            mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+            n?: number | undefined;
+            strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+            spendUsd?: number | null | undefined;
+        }, {
+            state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+            mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+            n?: number | undefined;
+            finishedAt?: string | null | undefined;
+            strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+            spendUsd?: number | null | undefined;
+            outputReadyState?: "pending" | "finalizing" | "ready" | "diagnostic" | undefined;
+            result?: {
+                kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+                diffStat?: {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                } | null | undefined;
+                blockers?: number | undefined;
+                adopted?: boolean | null | undefined;
+                applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+                preTurnSha?: string | null | undefined;
+                postTurnSha?: string | null | undefined;
+                revertable?: boolean | undefined;
+            } | undefined;
+            waitingOnUser?: boolean | undefined;
+        }>>>;
+        /** Why this turn has NO run (enqueue/preflight refusal, e.g. the trust
+         * gate) — surfaces render it as an inline failure card with the remedy;
+         * null once a run binds (retry clears it). `code` is the typed throw's
+         * machine code (remedies key on it, never on the message text);
+         * `retryable=false` means no recorded job exists to replay — surfaces
+         * offer "send a new message" instead of a doomed Retry. */
+        enqueueError: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            message: z.ZodString;
+            code: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            retryable: z.ZodDefault<z.ZodBoolean>;
+            failedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            code: string | null;
+            message: string;
+            retryable: boolean;
+            failedAt: string;
+        }, {
+            message: string;
+            failedAt: string;
+            code?: string | null | undefined;
+            retryable?: boolean | undefined;
+        }>>>;
+        createdAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "initial" | "followup" | "decision";
+        prompt: string;
+        planRunId: string | null;
+        runId: string | null;
+        threadId: string;
+        parentRunId: string | null;
+        createdAt: string;
+        run: {
+            state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+            finishedAt: string | null;
+            outputReadyState: "pending" | "finalizing" | "ready" | "diagnostic";
+            result: {
+                kind: "plan" | "none" | "patch" | "report" | "answer";
+                diffStat: {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                } | null;
+                blockers: number;
+                adopted: boolean | null;
+                applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+                preTurnSha: string | null;
+                postTurnSha: string | null;
+                revertable: boolean;
+            };
+            waitingOnUser: boolean;
+            mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+            n?: number | undefined;
+            strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+            spendUsd?: number | null | undefined;
+        } | null;
+        enqueueError: {
+            code: string | null;
+            message: string;
+            retryable: boolean;
+            failedAt: string;
+        } | null;
+    }, {
+        id: string;
+        threadId: string;
+        createdAt: string;
+        kind?: "initial" | "followup" | "decision" | undefined;
+        prompt?: string | undefined;
+        planRunId?: string | null | undefined;
+        runId?: string | null | undefined;
+        parentRunId?: string | null | undefined;
+        run?: {
+            state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+            mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+            n?: number | undefined;
+            finishedAt?: string | null | undefined;
+            strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+            spendUsd?: number | null | undefined;
+            outputReadyState?: "pending" | "finalizing" | "ready" | "diagnostic" | undefined;
+            result?: {
+                kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+                diffStat?: {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                } | null | undefined;
+                blockers?: number | undefined;
+                adopted?: boolean | null | undefined;
+                applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+                preTurnSha?: string | null | undefined;
+                postTurnSha?: string | null | undefined;
+                revertable?: boolean | undefined;
+            } | undefined;
+            waitingOnUser?: boolean | undefined;
+        } | null | undefined;
+        enqueueError?: {
+            message: string;
+            failedAt: string;
+            code?: string | null | undefined;
+            retryable?: boolean | undefined;
+        } | null | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    thread: {
+        id: string;
+        title: string | null;
+        state: "active" | "closed";
+        primaryHarness: string | null;
+        authPreference: "auto" | "subscription" | "api_key";
+        createdAt: string;
+        repoRoot: string | null;
+        workspaceMode: "in_place" | "isolated";
+        eligibleHarnesses: string[];
+        runIds: string[];
+        headRunId: string | null;
+        needsHuman: boolean;
+        updatedAt: string;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+    };
+    sessions: {
+        id: string;
+        state: "live" | "stale" | "rebound";
+        threadId: string;
+        harnessId: string;
+        observedModel: string | null;
+        nativeSessionId: string | null;
+    }[];
+    turns: {
+        id: string;
+        kind: "initial" | "followup" | "decision";
+        prompt: string;
+        planRunId: string | null;
+        runId: string | null;
+        threadId: string;
+        parentRunId: string | null;
+        createdAt: string;
+        run: {
+            state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+            finishedAt: string | null;
+            outputReadyState: "pending" | "finalizing" | "ready" | "diagnostic";
+            result: {
+                kind: "plan" | "none" | "patch" | "report" | "answer";
+                diffStat: {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                } | null;
+                blockers: number;
+                adopted: boolean | null;
+                applyState: "not_applied" | "applied" | "applied_review_blocked" | "reverted";
+                preTurnSha: string | null;
+                postTurnSha: string | null;
+                revertable: boolean;
+            };
+            waitingOnUser: boolean;
+            mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+            n?: number | undefined;
+            strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+            spendUsd?: number | null | undefined;
+        } | null;
+        enqueueError: {
+            code: string | null;
+            message: string;
+            retryable: boolean;
+            failedAt: string;
+        } | null;
+    }[];
+}, {
+    thread: {
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        title?: string | null | undefined;
+        mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+        state?: "active" | "closed" | undefined;
+        primaryHarness?: string | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        repoRoot?: string | null | undefined;
+        workspaceMode?: "in_place" | "isolated" | undefined;
+        eligibleHarnesses?: string[] | undefined;
+        runIds?: string[] | undefined;
+        headRunId?: string | null | undefined;
+        needsHuman?: boolean | undefined;
+    };
+    sessions?: {
+        id: string;
+        threadId: string;
+        harnessId: string;
+        state?: "live" | "stale" | "rebound" | undefined;
+        observedModel?: string | null | undefined;
+        nativeSessionId?: string | null | undefined;
+    }[] | undefined;
+    turns?: {
+        id: string;
+        threadId: string;
+        createdAt: string;
+        kind?: "initial" | "followup" | "decision" | undefined;
+        prompt?: string | undefined;
+        planRunId?: string | null | undefined;
+        runId?: string | null | undefined;
+        parentRunId?: string | null | undefined;
+        run?: {
+            state: "cancelled" | "no_op" | "ungated" | "review_not_run" | "blocked" | "not_converged" | "stuck_no_progress" | "failed" | "exhausted" | "running" | "queued" | "succeeded" | "interrupted";
+            mode?: "ask" | "plan" | "audit" | "agent" | "orchestrate" | undefined;
+            n?: number | undefined;
+            finishedAt?: string | null | undefined;
+            strategy?: "race" | "attempts" | "swarm" | "create" | "until_clean" | null | undefined;
+            spendUsd?: number | null | undefined;
+            outputReadyState?: "pending" | "finalizing" | "ready" | "diagnostic" | undefined;
+            result?: {
+                kind?: "plan" | "none" | "patch" | "report" | "answer" | undefined;
+                diffStat?: {
+                    files: number;
+                    additions: number;
+                    deletions: number;
+                } | null | undefined;
+                blockers?: number | undefined;
+                adopted?: boolean | null | undefined;
+                applyState?: "not_applied" | "applied" | "applied_review_blocked" | "reverted" | undefined;
+                preTurnSha?: string | null | undefined;
+                postTurnSha?: string | null | undefined;
+                revertable?: boolean | undefined;
+            } | undefined;
+            waitingOnUser?: boolean | undefined;
+        } | null | undefined;
+        enqueueError?: {
+            message: string;
+            failedAt: string;
+            code?: string | null | undefined;
+            retryable?: boolean | undefined;
+        } | null | undefined;
+    }[] | undefined;
+}>;
+export type ControlThreadDetail = z.infer<typeof ControlThreadDetail>;
+export declare const HarnessStatusDto: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<["ok", "degraded", "unavailable"]>;
+    manifest: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        display_name: z.ZodString;
+        kind: z.ZodEnum<["local_cli", "remote_api", "fake"]>;
+        version: z.ZodOptional<z.ZodString>;
+        adapter_version: z.ZodOptional<z.ZodString>;
+        provider_family: z.ZodDefault<z.ZodEnum<["openai", "anthropic", "google", "cursor", "opencode", "xai", "local", "unknown"]>>;
+        capability_profile: z.ZodDefault<z.ZodObject<{
+            auth: z.ZodDefault<z.ZodObject<{
+                supported_sources: z.ZodDefault<z.ZodArray<z.ZodEnum<["native_session", "api_key_env", "api_key_flag", "provider_auth_file", "none"]>, "many">>;
+                preferred_source: z.ZodDefault<z.ZodNullable<z.ZodEnum<["native_session", "api_key_env", "api_key_flag", "provider_auth_file", "none"]>>>;
+                credential_transports: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    source: z.ZodEnum<["native_session", "api_key_env", "api_key_flag", "provider_auth_file", "none"]>;
+                    kind: z.ZodEnum<["config_file", "env_var", "oauth_token_env", "os_keychain", "http_header", "none"]>;
+                    relocatable_by: z.ZodDefault<z.ZodArray<z.ZodEnum<["HOME", "CONFIG_DIR", "ENV", "none"]>, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                }, {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                supported_sources: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[];
+                preferred_source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null;
+                credential_transports: {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                }[];
+            }, {
+                supported_sources?: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[] | undefined;
+                preferred_source?: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null | undefined;
+                credential_transports?: {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                }[] | undefined;
+            }>>;
+            access_control: z.ZodDefault<z.ZodObject<{
+                readonly_mechanism: z.ZodDefault<z.ZodEnum<["fs_sandbox", "permission_deny", "tool_allowlist", "none"]>>;
+            }, "strip", z.ZodTypeAny, {
+                readonly_mechanism: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist";
+            }, {
+                readonly_mechanism?: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist" | undefined;
+            }>>;
+            isolation: z.ZodDefault<z.ZodObject<{
+                supported_containment: z.ZodDefault<z.ZodArray<z.ZodEnum<["env_or_file_injection", "scoped_home_keychain_bridge", "host_user_context", "process_sandbox", "container"]>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                supported_containment: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[];
+            }, {
+                supported_containment?: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[] | undefined;
+            }>>;
+            image_input: z.ZodDefault<z.ZodEnum<["file_path", "base64_stream", "base64_inline", "none"]>>;
+        }, "strip", z.ZodTypeAny, {
+            auth: {
+                supported_sources: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[];
+                preferred_source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null;
+                credential_transports: {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                }[];
+            };
+            access_control: {
+                readonly_mechanism: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist";
+            };
+            isolation: {
+                supported_containment: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[];
+            };
+            image_input: "file_path" | "base64_stream" | "base64_inline" | "none";
+        }, {
+            auth?: {
+                supported_sources?: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[] | undefined;
+                preferred_source?: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null | undefined;
+                credential_transports?: {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                }[] | undefined;
+            } | undefined;
+            access_control?: {
+                readonly_mechanism?: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist" | undefined;
+            } | undefined;
+            isolation?: {
+                supported_containment?: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[] | undefined;
+            } | undefined;
+            image_input?: "file_path" | "base64_stream" | "base64_inline" | "none" | undefined;
+        }>>;
+        capabilities: z.ZodObject<{
+            plan: z.ZodDefault<z.ZodBoolean>;
+            implement: z.ZodDefault<z.ZodBoolean>;
+            create_from_scratch: z.ZodDefault<z.ZodBoolean>;
+            review: z.ZodDefault<z.ZodBoolean>;
+            verify: z.ZodDefault<z.ZodBoolean>;
+            synthesize: z.ZodDefault<z.ZodBoolean>;
+            read_files: z.ZodDefault<z.ZodBoolean>;
+            browser_tool: z.ZodDefault<z.ZodBoolean>;
+            web_policy: z.ZodDefault<z.ZodEnum<["native", "tools", "uncontrolled", "none"]>>;
+            max_turns: z.ZodDefault<z.ZodBoolean>;
+            tool_lists: z.ZodDefault<z.ZodBoolean>;
+            interactive: z.ZodDefault<z.ZodBoolean>;
+            orchestrate: z.ZodDefault<z.ZodBoolean>;
+            json_schema_output: z.ZodDefault<z.ZodBoolean>;
+            effort_levels: z.ZodDefault<z.ZodArray<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>, "many">>;
+            known_models: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            known_models_verified_against: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            plan: boolean;
+            orchestrate: boolean;
+            implement: boolean;
+            create_from_scratch: boolean;
+            review: boolean;
+            verify: boolean;
+            synthesize: boolean;
+            read_files: boolean;
+            browser_tool: boolean;
+            web_policy: "none" | "native" | "tools" | "uncontrolled";
+            max_turns: boolean;
+            tool_lists: boolean;
+            interactive: boolean;
+            json_schema_output: boolean;
+            effort_levels: ("low" | "medium" | "high" | "xhigh" | "max")[];
+            known_models: string[];
+            known_models_verified_against: string | null;
+        }, {
+            plan?: boolean | undefined;
+            orchestrate?: boolean | undefined;
+            implement?: boolean | undefined;
+            create_from_scratch?: boolean | undefined;
+            review?: boolean | undefined;
+            verify?: boolean | undefined;
+            synthesize?: boolean | undefined;
+            read_files?: boolean | undefined;
+            browser_tool?: boolean | undefined;
+            web_policy?: "none" | "native" | "tools" | "uncontrolled" | undefined;
+            max_turns?: boolean | undefined;
+            tool_lists?: boolean | undefined;
+            interactive?: boolean | undefined;
+            json_schema_output?: boolean | undefined;
+            effort_levels?: ("low" | "medium" | "high" | "xhigh" | "max")[] | undefined;
+            known_models?: string[] | undefined;
+            known_models_verified_against?: string | null | undefined;
+        }>;
+        auth_modes: z.ZodDefault<z.ZodArray<z.ZodEnum<["local_session", "api_key", "none"]>, "many">>;
+        access_profiles_supported: z.ZodDefault<z.ZodArray<z.ZodEnum<["readonly", "workspace_write", "full", "external_sandbox_full", "inherit_native"]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "local_cli" | "remote_api" | "fake";
+        display_name: string;
+        provider_family: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown";
+        capability_profile: {
+            auth: {
+                supported_sources: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[];
+                preferred_source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null;
+                credential_transports: {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                }[];
+            };
+            access_control: {
+                readonly_mechanism: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist";
+            };
+            isolation: {
+                supported_containment: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[];
+            };
+            image_input: "file_path" | "base64_stream" | "base64_inline" | "none";
+        };
+        capabilities: {
+            plan: boolean;
+            orchestrate: boolean;
+            implement: boolean;
+            create_from_scratch: boolean;
+            review: boolean;
+            verify: boolean;
+            synthesize: boolean;
+            read_files: boolean;
+            browser_tool: boolean;
+            web_policy: "none" | "native" | "tools" | "uncontrolled";
+            max_turns: boolean;
+            tool_lists: boolean;
+            interactive: boolean;
+            json_schema_output: boolean;
+            effort_levels: ("low" | "medium" | "high" | "xhigh" | "max")[];
+            known_models: string[];
+            known_models_verified_against: string | null;
+        };
+        auth_modes: ("api_key" | "none" | "local_session")[];
+        access_profiles_supported: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[];
+        version?: string | undefined;
+        adapter_version?: string | undefined;
+    }, {
+        id: string;
+        kind: "local_cli" | "remote_api" | "fake";
+        display_name: string;
+        capabilities: {
+            plan?: boolean | undefined;
+            orchestrate?: boolean | undefined;
+            implement?: boolean | undefined;
+            create_from_scratch?: boolean | undefined;
+            review?: boolean | undefined;
+            verify?: boolean | undefined;
+            synthesize?: boolean | undefined;
+            read_files?: boolean | undefined;
+            browser_tool?: boolean | undefined;
+            web_policy?: "none" | "native" | "tools" | "uncontrolled" | undefined;
+            max_turns?: boolean | undefined;
+            tool_lists?: boolean | undefined;
+            interactive?: boolean | undefined;
+            json_schema_output?: boolean | undefined;
+            effort_levels?: ("low" | "medium" | "high" | "xhigh" | "max")[] | undefined;
+            known_models?: string[] | undefined;
+            known_models_verified_against?: string | null | undefined;
+        };
+        version?: string | undefined;
+        adapter_version?: string | undefined;
+        provider_family?: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown" | undefined;
+        capability_profile?: {
+            auth?: {
+                supported_sources?: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[] | undefined;
+                preferred_source?: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null | undefined;
+                credential_transports?: {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                }[] | undefined;
+            } | undefined;
+            access_control?: {
+                readonly_mechanism?: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist" | undefined;
+            } | undefined;
+            isolation?: {
+                supported_containment?: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[] | undefined;
+            } | undefined;
+            image_input?: "file_path" | "base64_stream" | "base64_inline" | "none" | undefined;
+        } | undefined;
+        auth_modes?: ("api_key" | "none" | "local_session")[] | undefined;
+        access_profiles_supported?: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[] | undefined;
+    }>>>;
+    enabledIntents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    disabledIntents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<["pass", "fail", "skip"]>;
+        detail: z.ZodOptional<z.ZodString>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: "pass" | "fail" | "skip";
+        id: string;
+        detail?: string | undefined;
+        duration_ms?: number | undefined;
+    }, {
+        status: "pass" | "fail" | "skip";
+        id: string;
+        detail?: string | undefined;
+        duration_ms?: number | undefined;
+    }>, "many">>;
+    reasons: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** The user's configured per-harness default model, if any. */
+    configuredModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Strict truth-source check of `configuredModel`: null when no model
+     * is configured; a rejection carries the actionable message so UIs render
+     * the same honesty `claudexor doctor` prints. */
+    configuredModelCheck: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<["ok", "rejected"]>;
+        message: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        message: string | null;
+        status: "ok" | "rejected";
+    }, {
+        status: "ok" | "rejected";
+        message?: string | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    status: "ok" | "degraded" | "unavailable";
+    id: string;
+    checks: {
+        status: "pass" | "fail" | "skip";
+        id: string;
+        detail?: string | undefined;
+        duration_ms?: number | undefined;
+    }[];
+    reasons: string[];
+    enabledIntents: string[];
+    disabledIntents: string[];
+    configuredModel: string | null;
+    configuredModelCheck: {
+        message: string | null;
+        status: "ok" | "rejected";
+    } | null;
+    manifest?: {
+        id: string;
+        kind: "local_cli" | "remote_api" | "fake";
+        display_name: string;
+        provider_family: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown";
+        capability_profile: {
+            auth: {
+                supported_sources: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[];
+                preferred_source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null;
+                credential_transports: {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                }[];
+            };
+            access_control: {
+                readonly_mechanism: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist";
+            };
+            isolation: {
+                supported_containment: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[];
+            };
+            image_input: "file_path" | "base64_stream" | "base64_inline" | "none";
+        };
+        capabilities: {
+            plan: boolean;
+            orchestrate: boolean;
+            implement: boolean;
+            create_from_scratch: boolean;
+            review: boolean;
+            verify: boolean;
+            synthesize: boolean;
+            read_files: boolean;
+            browser_tool: boolean;
+            web_policy: "none" | "native" | "tools" | "uncontrolled";
+            max_turns: boolean;
+            tool_lists: boolean;
+            interactive: boolean;
+            json_schema_output: boolean;
+            effort_levels: ("low" | "medium" | "high" | "xhigh" | "max")[];
+            known_models: string[];
+            known_models_verified_against: string | null;
+        };
+        auth_modes: ("api_key" | "none" | "local_session")[];
+        access_profiles_supported: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[];
+        version?: string | undefined;
+        adapter_version?: string | undefined;
+    } | null | undefined;
+}, {
+    status: "ok" | "degraded" | "unavailable";
+    id: string;
+    checks?: {
+        status: "pass" | "fail" | "skip";
+        id: string;
+        detail?: string | undefined;
+        duration_ms?: number | undefined;
+    }[] | undefined;
+    reasons?: string[] | undefined;
+    manifest?: {
+        id: string;
+        kind: "local_cli" | "remote_api" | "fake";
+        display_name: string;
+        capabilities: {
+            plan?: boolean | undefined;
+            orchestrate?: boolean | undefined;
+            implement?: boolean | undefined;
+            create_from_scratch?: boolean | undefined;
+            review?: boolean | undefined;
+            verify?: boolean | undefined;
+            synthesize?: boolean | undefined;
+            read_files?: boolean | undefined;
+            browser_tool?: boolean | undefined;
+            web_policy?: "none" | "native" | "tools" | "uncontrolled" | undefined;
+            max_turns?: boolean | undefined;
+            tool_lists?: boolean | undefined;
+            interactive?: boolean | undefined;
+            json_schema_output?: boolean | undefined;
+            effort_levels?: ("low" | "medium" | "high" | "xhigh" | "max")[] | undefined;
+            known_models?: string[] | undefined;
+            known_models_verified_against?: string | null | undefined;
+        };
+        version?: string | undefined;
+        adapter_version?: string | undefined;
+        provider_family?: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown" | undefined;
+        capability_profile?: {
+            auth?: {
+                supported_sources?: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[] | undefined;
+                preferred_source?: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null | undefined;
+                credential_transports?: {
+                    kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                    source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                    relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                }[] | undefined;
+            } | undefined;
+            access_control?: {
+                readonly_mechanism?: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist" | undefined;
+            } | undefined;
+            isolation?: {
+                supported_containment?: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[] | undefined;
+            } | undefined;
+            image_input?: "file_path" | "base64_stream" | "base64_inline" | "none" | undefined;
+        } | undefined;
+        auth_modes?: ("api_key" | "none" | "local_session")[] | undefined;
+        access_profiles_supported?: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[] | undefined;
+    } | null | undefined;
+    enabledIntents?: string[] | undefined;
+    disabledIntents?: string[] | undefined;
+    configuredModel?: string | null | undefined;
+    configuredModelCheck?: {
+        status: "ok" | "rejected";
+        message?: string | null | undefined;
+    } | null | undefined;
+}>;
+export type HarnessStatusDto = z.infer<typeof HarnessStatusDto>;
+export declare const ControlHarnessListResponse: z.ZodObject<{
+    harnesses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<["ok", "degraded", "unavailable"]>;
+        manifest: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            display_name: z.ZodString;
+            kind: z.ZodEnum<["local_cli", "remote_api", "fake"]>;
+            version: z.ZodOptional<z.ZodString>;
+            adapter_version: z.ZodOptional<z.ZodString>;
+            provider_family: z.ZodDefault<z.ZodEnum<["openai", "anthropic", "google", "cursor", "opencode", "xai", "local", "unknown"]>>;
+            capability_profile: z.ZodDefault<z.ZodObject<{
+                auth: z.ZodDefault<z.ZodObject<{
+                    supported_sources: z.ZodDefault<z.ZodArray<z.ZodEnum<["native_session", "api_key_env", "api_key_flag", "provider_auth_file", "none"]>, "many">>;
+                    preferred_source: z.ZodDefault<z.ZodNullable<z.ZodEnum<["native_session", "api_key_env", "api_key_flag", "provider_auth_file", "none"]>>>;
+                    credential_transports: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        source: z.ZodEnum<["native_session", "api_key_env", "api_key_flag", "provider_auth_file", "none"]>;
+                        kind: z.ZodEnum<["config_file", "env_var", "oauth_token_env", "os_keychain", "http_header", "none"]>;
+                        relocatable_by: z.ZodDefault<z.ZodArray<z.ZodEnum<["HOME", "CONFIG_DIR", "ENV", "none"]>, "many">>;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                    }, {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                    }>, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    supported_sources: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[];
+                    preferred_source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null;
+                    credential_transports: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                    }[];
+                }, {
+                    supported_sources?: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[] | undefined;
+                    preferred_source?: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null | undefined;
+                    credential_transports?: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                    }[] | undefined;
+                }>>;
+                access_control: z.ZodDefault<z.ZodObject<{
+                    readonly_mechanism: z.ZodDefault<z.ZodEnum<["fs_sandbox", "permission_deny", "tool_allowlist", "none"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    readonly_mechanism: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist";
+                }, {
+                    readonly_mechanism?: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist" | undefined;
+                }>>;
+                isolation: z.ZodDefault<z.ZodObject<{
+                    supported_containment: z.ZodDefault<z.ZodArray<z.ZodEnum<["env_or_file_injection", "scoped_home_keychain_bridge", "host_user_context", "process_sandbox", "container"]>, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    supported_containment: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[];
+                }, {
+                    supported_containment?: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[] | undefined;
+                }>>;
+                image_input: z.ZodDefault<z.ZodEnum<["file_path", "base64_stream", "base64_inline", "none"]>>;
+            }, "strip", z.ZodTypeAny, {
+                auth: {
+                    supported_sources: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[];
+                    preferred_source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null;
+                    credential_transports: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                    }[];
+                };
+                access_control: {
+                    readonly_mechanism: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist";
+                };
+                isolation: {
+                    supported_containment: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[];
+                };
+                image_input: "file_path" | "base64_stream" | "base64_inline" | "none";
+            }, {
+                auth?: {
+                    supported_sources?: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[] | undefined;
+                    preferred_source?: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null | undefined;
+                    credential_transports?: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                    }[] | undefined;
+                } | undefined;
+                access_control?: {
+                    readonly_mechanism?: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist" | undefined;
+                } | undefined;
+                isolation?: {
+                    supported_containment?: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[] | undefined;
+                } | undefined;
+                image_input?: "file_path" | "base64_stream" | "base64_inline" | "none" | undefined;
+            }>>;
+            capabilities: z.ZodObject<{
+                plan: z.ZodDefault<z.ZodBoolean>;
+                implement: z.ZodDefault<z.ZodBoolean>;
+                create_from_scratch: z.ZodDefault<z.ZodBoolean>;
+                review: z.ZodDefault<z.ZodBoolean>;
+                verify: z.ZodDefault<z.ZodBoolean>;
+                synthesize: z.ZodDefault<z.ZodBoolean>;
+                read_files: z.ZodDefault<z.ZodBoolean>;
+                browser_tool: z.ZodDefault<z.ZodBoolean>;
+                web_policy: z.ZodDefault<z.ZodEnum<["native", "tools", "uncontrolled", "none"]>>;
+                max_turns: z.ZodDefault<z.ZodBoolean>;
+                tool_lists: z.ZodDefault<z.ZodBoolean>;
+                interactive: z.ZodDefault<z.ZodBoolean>;
+                orchestrate: z.ZodDefault<z.ZodBoolean>;
+                json_schema_output: z.ZodDefault<z.ZodBoolean>;
+                effort_levels: z.ZodDefault<z.ZodArray<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>, "many">>;
+                known_models: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                known_models_verified_against: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                plan: boolean;
+                orchestrate: boolean;
+                implement: boolean;
+                create_from_scratch: boolean;
+                review: boolean;
+                verify: boolean;
+                synthesize: boolean;
+                read_files: boolean;
+                browser_tool: boolean;
+                web_policy: "none" | "native" | "tools" | "uncontrolled";
+                max_turns: boolean;
+                tool_lists: boolean;
+                interactive: boolean;
+                json_schema_output: boolean;
+                effort_levels: ("low" | "medium" | "high" | "xhigh" | "max")[];
+                known_models: string[];
+                known_models_verified_against: string | null;
+            }, {
+                plan?: boolean | undefined;
+                orchestrate?: boolean | undefined;
+                implement?: boolean | undefined;
+                create_from_scratch?: boolean | undefined;
+                review?: boolean | undefined;
+                verify?: boolean | undefined;
+                synthesize?: boolean | undefined;
+                read_files?: boolean | undefined;
+                browser_tool?: boolean | undefined;
+                web_policy?: "none" | "native" | "tools" | "uncontrolled" | undefined;
+                max_turns?: boolean | undefined;
+                tool_lists?: boolean | undefined;
+                interactive?: boolean | undefined;
+                json_schema_output?: boolean | undefined;
+                effort_levels?: ("low" | "medium" | "high" | "xhigh" | "max")[] | undefined;
+                known_models?: string[] | undefined;
+                known_models_verified_against?: string | null | undefined;
+            }>;
+            auth_modes: z.ZodDefault<z.ZodArray<z.ZodEnum<["local_session", "api_key", "none"]>, "many">>;
+            access_profiles_supported: z.ZodDefault<z.ZodArray<z.ZodEnum<["readonly", "workspace_write", "full", "external_sandbox_full", "inherit_native"]>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            kind: "local_cli" | "remote_api" | "fake";
+            display_name: string;
+            provider_family: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown";
+            capability_profile: {
+                auth: {
+                    supported_sources: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[];
+                    preferred_source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null;
+                    credential_transports: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                    }[];
+                };
+                access_control: {
+                    readonly_mechanism: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist";
+                };
+                isolation: {
+                    supported_containment: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[];
+                };
+                image_input: "file_path" | "base64_stream" | "base64_inline" | "none";
+            };
+            capabilities: {
+                plan: boolean;
+                orchestrate: boolean;
+                implement: boolean;
+                create_from_scratch: boolean;
+                review: boolean;
+                verify: boolean;
+                synthesize: boolean;
+                read_files: boolean;
+                browser_tool: boolean;
+                web_policy: "none" | "native" | "tools" | "uncontrolled";
+                max_turns: boolean;
+                tool_lists: boolean;
+                interactive: boolean;
+                json_schema_output: boolean;
+                effort_levels: ("low" | "medium" | "high" | "xhigh" | "max")[];
+                known_models: string[];
+                known_models_verified_against: string | null;
+            };
+            auth_modes: ("api_key" | "none" | "local_session")[];
+            access_profiles_supported: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[];
+            version?: string | undefined;
+            adapter_version?: string | undefined;
+        }, {
+            id: string;
+            kind: "local_cli" | "remote_api" | "fake";
+            display_name: string;
+            capabilities: {
+                plan?: boolean | undefined;
+                orchestrate?: boolean | undefined;
+                implement?: boolean | undefined;
+                create_from_scratch?: boolean | undefined;
+                review?: boolean | undefined;
+                verify?: boolean | undefined;
+                synthesize?: boolean | undefined;
+                read_files?: boolean | undefined;
+                browser_tool?: boolean | undefined;
+                web_policy?: "none" | "native" | "tools" | "uncontrolled" | undefined;
+                max_turns?: boolean | undefined;
+                tool_lists?: boolean | undefined;
+                interactive?: boolean | undefined;
+                json_schema_output?: boolean | undefined;
+                effort_levels?: ("low" | "medium" | "high" | "xhigh" | "max")[] | undefined;
+                known_models?: string[] | undefined;
+                known_models_verified_against?: string | null | undefined;
+            };
+            version?: string | undefined;
+            adapter_version?: string | undefined;
+            provider_family?: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown" | undefined;
+            capability_profile?: {
+                auth?: {
+                    supported_sources?: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[] | undefined;
+                    preferred_source?: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null | undefined;
+                    credential_transports?: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                    }[] | undefined;
+                } | undefined;
+                access_control?: {
+                    readonly_mechanism?: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist" | undefined;
+                } | undefined;
+                isolation?: {
+                    supported_containment?: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[] | undefined;
+                } | undefined;
+                image_input?: "file_path" | "base64_stream" | "base64_inline" | "none" | undefined;
+            } | undefined;
+            auth_modes?: ("api_key" | "none" | "local_session")[] | undefined;
+            access_profiles_supported?: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[] | undefined;
+        }>>>;
+        enabledIntents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        disabledIntents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<["pass", "fail", "skip"]>;
+            detail: z.ZodOptional<z.ZodString>;
+            duration_ms: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "pass" | "fail" | "skip";
+            id: string;
+            detail?: string | undefined;
+            duration_ms?: number | undefined;
+        }, {
+            status: "pass" | "fail" | "skip";
+            id: string;
+            detail?: string | undefined;
+            duration_ms?: number | undefined;
+        }>, "many">>;
+        reasons: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** The user's configured per-harness default model, if any. */
+        configuredModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Strict truth-source check of `configuredModel`: null when no model
+         * is configured; a rejection carries the actionable message so UIs render
+         * the same honesty `claudexor doctor` prints. */
+        configuredModelCheck: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            status: z.ZodEnum<["ok", "rejected"]>;
+            message: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            message: string | null;
+            status: "ok" | "rejected";
+        }, {
+            status: "ok" | "rejected";
+            message?: string | null | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "ok" | "degraded" | "unavailable";
+        id: string;
+        checks: {
+            status: "pass" | "fail" | "skip";
+            id: string;
+            detail?: string | undefined;
+            duration_ms?: number | undefined;
+        }[];
+        reasons: string[];
+        enabledIntents: string[];
+        disabledIntents: string[];
+        configuredModel: string | null;
+        configuredModelCheck: {
+            message: string | null;
+            status: "ok" | "rejected";
+        } | null;
+        manifest?: {
+            id: string;
+            kind: "local_cli" | "remote_api" | "fake";
+            display_name: string;
+            provider_family: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown";
+            capability_profile: {
+                auth: {
+                    supported_sources: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[];
+                    preferred_source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null;
+                    credential_transports: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                    }[];
+                };
+                access_control: {
+                    readonly_mechanism: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist";
+                };
+                isolation: {
+                    supported_containment: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[];
+                };
+                image_input: "file_path" | "base64_stream" | "base64_inline" | "none";
+            };
+            capabilities: {
+                plan: boolean;
+                orchestrate: boolean;
+                implement: boolean;
+                create_from_scratch: boolean;
+                review: boolean;
+                verify: boolean;
+                synthesize: boolean;
+                read_files: boolean;
+                browser_tool: boolean;
+                web_policy: "none" | "native" | "tools" | "uncontrolled";
+                max_turns: boolean;
+                tool_lists: boolean;
+                interactive: boolean;
+                json_schema_output: boolean;
+                effort_levels: ("low" | "medium" | "high" | "xhigh" | "max")[];
+                known_models: string[];
+                known_models_verified_against: string | null;
+            };
+            auth_modes: ("api_key" | "none" | "local_session")[];
+            access_profiles_supported: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[];
+            version?: string | undefined;
+            adapter_version?: string | undefined;
+        } | null | undefined;
+    }, {
+        status: "ok" | "degraded" | "unavailable";
+        id: string;
+        checks?: {
+            status: "pass" | "fail" | "skip";
+            id: string;
+            detail?: string | undefined;
+            duration_ms?: number | undefined;
+        }[] | undefined;
+        reasons?: string[] | undefined;
+        manifest?: {
+            id: string;
+            kind: "local_cli" | "remote_api" | "fake";
+            display_name: string;
+            capabilities: {
+                plan?: boolean | undefined;
+                orchestrate?: boolean | undefined;
+                implement?: boolean | undefined;
+                create_from_scratch?: boolean | undefined;
+                review?: boolean | undefined;
+                verify?: boolean | undefined;
+                synthesize?: boolean | undefined;
+                read_files?: boolean | undefined;
+                browser_tool?: boolean | undefined;
+                web_policy?: "none" | "native" | "tools" | "uncontrolled" | undefined;
+                max_turns?: boolean | undefined;
+                tool_lists?: boolean | undefined;
+                interactive?: boolean | undefined;
+                json_schema_output?: boolean | undefined;
+                effort_levels?: ("low" | "medium" | "high" | "xhigh" | "max")[] | undefined;
+                known_models?: string[] | undefined;
+                known_models_verified_against?: string | null | undefined;
+            };
+            version?: string | undefined;
+            adapter_version?: string | undefined;
+            provider_family?: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown" | undefined;
+            capability_profile?: {
+                auth?: {
+                    supported_sources?: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[] | undefined;
+                    preferred_source?: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null | undefined;
+                    credential_transports?: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                    }[] | undefined;
+                } | undefined;
+                access_control?: {
+                    readonly_mechanism?: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist" | undefined;
+                } | undefined;
+                isolation?: {
+                    supported_containment?: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[] | undefined;
+                } | undefined;
+                image_input?: "file_path" | "base64_stream" | "base64_inline" | "none" | undefined;
+            } | undefined;
+            auth_modes?: ("api_key" | "none" | "local_session")[] | undefined;
+            access_profiles_supported?: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[] | undefined;
+        } | null | undefined;
+        enabledIntents?: string[] | undefined;
+        disabledIntents?: string[] | undefined;
+        configuredModel?: string | null | undefined;
+        configuredModelCheck?: {
+            status: "ok" | "rejected";
+            message?: string | null | undefined;
+        } | null | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    harnesses: {
+        status: "ok" | "degraded" | "unavailable";
+        id: string;
+        checks: {
+            status: "pass" | "fail" | "skip";
+            id: string;
+            detail?: string | undefined;
+            duration_ms?: number | undefined;
+        }[];
+        reasons: string[];
+        enabledIntents: string[];
+        disabledIntents: string[];
+        configuredModel: string | null;
+        configuredModelCheck: {
+            message: string | null;
+            status: "ok" | "rejected";
+        } | null;
+        manifest?: {
+            id: string;
+            kind: "local_cli" | "remote_api" | "fake";
+            display_name: string;
+            provider_family: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown";
+            capability_profile: {
+                auth: {
+                    supported_sources: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[];
+                    preferred_source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null;
+                    credential_transports: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[];
+                    }[];
+                };
+                access_control: {
+                    readonly_mechanism: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist";
+                };
+                isolation: {
+                    supported_containment: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[];
+                };
+                image_input: "file_path" | "base64_stream" | "base64_inline" | "none";
+            };
+            capabilities: {
+                plan: boolean;
+                orchestrate: boolean;
+                implement: boolean;
+                create_from_scratch: boolean;
+                review: boolean;
+                verify: boolean;
+                synthesize: boolean;
+                read_files: boolean;
+                browser_tool: boolean;
+                web_policy: "none" | "native" | "tools" | "uncontrolled";
+                max_turns: boolean;
+                tool_lists: boolean;
+                interactive: boolean;
+                json_schema_output: boolean;
+                effort_levels: ("low" | "medium" | "high" | "xhigh" | "max")[];
+                known_models: string[];
+                known_models_verified_against: string | null;
+            };
+            auth_modes: ("api_key" | "none" | "local_session")[];
+            access_profiles_supported: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[];
+            version?: string | undefined;
+            adapter_version?: string | undefined;
+        } | null | undefined;
+    }[];
+}, {
+    harnesses?: {
+        status: "ok" | "degraded" | "unavailable";
+        id: string;
+        checks?: {
+            status: "pass" | "fail" | "skip";
+            id: string;
+            detail?: string | undefined;
+            duration_ms?: number | undefined;
+        }[] | undefined;
+        reasons?: string[] | undefined;
+        manifest?: {
+            id: string;
+            kind: "local_cli" | "remote_api" | "fake";
+            display_name: string;
+            capabilities: {
+                plan?: boolean | undefined;
+                orchestrate?: boolean | undefined;
+                implement?: boolean | undefined;
+                create_from_scratch?: boolean | undefined;
+                review?: boolean | undefined;
+                verify?: boolean | undefined;
+                synthesize?: boolean | undefined;
+                read_files?: boolean | undefined;
+                browser_tool?: boolean | undefined;
+                web_policy?: "none" | "native" | "tools" | "uncontrolled" | undefined;
+                max_turns?: boolean | undefined;
+                tool_lists?: boolean | undefined;
+                interactive?: boolean | undefined;
+                json_schema_output?: boolean | undefined;
+                effort_levels?: ("low" | "medium" | "high" | "xhigh" | "max")[] | undefined;
+                known_models?: string[] | undefined;
+                known_models_verified_against?: string | null | undefined;
+            };
+            version?: string | undefined;
+            adapter_version?: string | undefined;
+            provider_family?: "openai" | "anthropic" | "google" | "cursor" | "opencode" | "xai" | "local" | "unknown" | undefined;
+            capability_profile?: {
+                auth?: {
+                    supported_sources?: ("none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file")[] | undefined;
+                    preferred_source?: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file" | null | undefined;
+                    credential_transports?: {
+                        kind: "none" | "config_file" | "env_var" | "oauth_token_env" | "os_keychain" | "http_header";
+                        source: "none" | "native_session" | "api_key_env" | "api_key_flag" | "provider_auth_file";
+                        relocatable_by?: ("none" | "HOME" | "CONFIG_DIR" | "ENV")[] | undefined;
+                    }[] | undefined;
+                } | undefined;
+                access_control?: {
+                    readonly_mechanism?: "none" | "fs_sandbox" | "permission_deny" | "tool_allowlist" | undefined;
+                } | undefined;
+                isolation?: {
+                    supported_containment?: ("env_or_file_injection" | "scoped_home_keychain_bridge" | "host_user_context" | "process_sandbox" | "container")[] | undefined;
+                } | undefined;
+                image_input?: "file_path" | "base64_stream" | "base64_inline" | "none" | undefined;
+            } | undefined;
+            auth_modes?: ("api_key" | "none" | "local_session")[] | undefined;
+            access_profiles_supported?: ("readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native")[] | undefined;
+        } | null | undefined;
+        enabledIntents?: string[] | undefined;
+        disabledIntents?: string[] | undefined;
+        configuredModel?: string | null | undefined;
+        configuredModelCheck?: {
+            status: "ok" | "rejected";
+            message?: string | null | undefined;
+        } | null | undefined;
+    }[] | undefined;
+}>;
+export type ControlHarnessListResponse = z.infer<typeof ControlHarnessListResponse>;
+/**
+ * Models enumerable for one harness. `source` is honest about provenance:
+ * "api" when the adapter implemented a real enumeration (raw-api / OpenAI
+ * `GET /v1/models`), "manifest" when the list is the manifest's known-good
+ * hint set, "none" when the harness has no model truth source at all (the
+ * list is then empty and explicit models are refused under strict model-truth validation).
+ */
+export declare const ControlHarnessModelsResponse: z.ZodObject<{
+    harnessId: z.ZodString;
+    models: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        context_window: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string | null;
+        context_window: number | null;
+    }, {
+        id: string;
+        label?: string | null | undefined;
+        context_window?: number | null | undefined;
+    }>, "many">>;
+    source: z.ZodEnum<["api", "manifest", "none"]>;
+    /** Freshness note for manifest-sourced lists: the vendor CLI version the
+     * known-model hints were last verified against (null for api/none). */
+    verifiedAgainst: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    source: "none" | "api" | "manifest";
+    verifiedAgainst: string | null;
+    models: {
+        id: string;
+        label: string | null;
+        context_window: number | null;
+    }[];
+    harnessId: string;
+}, {
+    source: "none" | "api" | "manifest";
+    harnessId: string;
+    verifiedAgainst?: string | null | undefined;
+    models?: {
+        id: string;
+        label?: string | null | undefined;
+        context_window?: number | null | undefined;
+    }[] | undefined;
+}>;
+export type ControlHarnessModelsResponse = z.infer<typeof ControlHarnessModelsResponse>;
+export declare const ControlSettingsSnapshot: z.ZodObject<{
+    sources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    defaultPortfolio: z.ZodDefault<z.ZodEnum<["daily-rich", "balanced", "cheapest", "strongest", "burn", "subscription-first", "api-overflow", "conserve-claude", "conserve-codex"]>>;
+    /** How long a run waits for an interactive answer before a benign decline. */
+    interactionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    routing: z.ZodDefault<z.ZodObject<{
+        defaultPolicy: z.ZodDefault<z.ZodEnum<["auto", "primary"]>>;
+        primaryHarness: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        eligibleHarnesses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        envInheritance: z.ZodDefault<z.ZodEnum<["mirror_native", "clean"]>>;
+        authPreference: z.ZodDefault<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+    }, "strip", z.ZodTypeAny, {
+        primaryHarness: string | null;
+        authPreference: "auto" | "subscription" | "api_key";
+        eligibleHarnesses: string[];
+        defaultPolicy: "auto" | "primary";
+        envInheritance: "mirror_native" | "clean";
+    }, {
+        primaryHarness?: string | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        eligibleHarnesses?: string[] | undefined;
+        defaultPolicy?: "auto" | "primary" | undefined;
+        envInheritance?: "mirror_native" | "clean" | undefined;
+    }>>;
+    budget: z.ZodDefault<z.ZodObject<{
+        maxUsdPerRun: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        maxUsdPerRun: number | null;
+    }, {
+        maxUsdPerRun?: number | null | undefined;
+    }>>;
+    runtime: z.ZodDefault<z.ZodObject<{
+        reviewerTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        harnessInactivityTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        transientRetry: z.ZodDefault<z.ZodObject<{
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            initialDelayMs: z.ZodDefault<z.ZodNumber>;
+            maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxRetries: number;
+            initialDelayMs: number;
+            maxDelayMs: number;
+        }, {
+            maxRetries?: number | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        reviewerTimeoutMs: number;
+        harnessInactivityTimeoutMs: number;
+        transientRetry: {
+            maxRetries: number;
+            initialDelayMs: number;
+            maxDelayMs: number;
+        };
+    }, {
+        reviewerTimeoutMs?: number | undefined;
+        harnessInactivityTimeoutMs?: number | undefined;
+        transientRetry?: {
+            maxRetries?: number | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        } | undefined;
+    }>>;
+    harnesses: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        defaultModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        effort: z.ZodDefault<z.ZodNullable<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>>;
+        maxTurns: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        maxRounds: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        maxUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toolsAllow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        toolsDeny: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        fallbackModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        web: z.ZodDefault<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+        authPreference: z.ZodDefault<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+    }, "strip", z.ZodTypeAny, {
+        web: "off" | "auto" | "cached" | "live";
+        enabled: boolean;
+        effort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+        maxUsd: number | null;
+        authPreference: "auto" | "subscription" | "api_key";
+        defaultModel: string | null;
+        maxTurns: number | null;
+        maxRounds: number | null;
+        toolsAllow: string[];
+        toolsDeny: string[];
+        fallbackModel: string | null;
+    }, {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        enabled?: boolean | undefined;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+        maxUsd?: number | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        defaultModel?: string | null | undefined;
+        maxTurns?: number | null | undefined;
+        maxRounds?: number | null | undefined;
+        toolsAllow?: string[] | undefined;
+        toolsDeny?: string[] | undefined;
+        fallbackModel?: string | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    harnesses: Record<string, {
+        web: "off" | "auto" | "cached" | "live";
+        enabled: boolean;
+        effort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+        maxUsd: number | null;
+        authPreference: "auto" | "subscription" | "api_key";
+        defaultModel: string | null;
+        maxTurns: number | null;
+        maxRounds: number | null;
+        toolsAllow: string[];
+        toolsDeny: string[];
+        fallbackModel: string | null;
+    }>;
+    budget: {
+        maxUsdPerRun: number | null;
+    };
+    routing: {
+        primaryHarness: string | null;
+        authPreference: "auto" | "subscription" | "api_key";
+        eligibleHarnesses: string[];
+        defaultPolicy: "auto" | "primary";
+        envInheritance: "mirror_native" | "clean";
+    };
+    runtime: {
+        reviewerTimeoutMs: number;
+        harnessInactivityTimeoutMs: number;
+        transientRetry: {
+            maxRetries: number;
+            initialDelayMs: number;
+            maxDelayMs: number;
+        };
+    };
+    sources: string[];
+    defaultPortfolio: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex";
+    interactionTimeoutMs: number;
+}, {
+    harnesses?: Record<string, {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        enabled?: boolean | undefined;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+        maxUsd?: number | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        defaultModel?: string | null | undefined;
+        maxTurns?: number | null | undefined;
+        maxRounds?: number | null | undefined;
+        toolsAllow?: string[] | undefined;
+        toolsDeny?: string[] | undefined;
+        fallbackModel?: string | null | undefined;
+    }> | undefined;
+    budget?: {
+        maxUsdPerRun?: number | null | undefined;
+    } | undefined;
+    routing?: {
+        primaryHarness?: string | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        eligibleHarnesses?: string[] | undefined;
+        defaultPolicy?: "auto" | "primary" | undefined;
+        envInheritance?: "mirror_native" | "clean" | undefined;
+    } | undefined;
+    runtime?: {
+        reviewerTimeoutMs?: number | undefined;
+        harnessInactivityTimeoutMs?: number | undefined;
+        transientRetry?: {
+            maxRetries?: number | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        } | undefined;
+    } | undefined;
+    sources?: string[] | undefined;
+    defaultPortfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    interactionTimeoutMs?: number | undefined;
+}>;
+export type ControlSettingsSnapshot = z.infer<typeof ControlSettingsSnapshot>;
+/**
+ * Partial per-harness settings patch; absent fields keep their stored value.
+ * STRICT: a typoed key must 400, not silently no-op (fail-loudly contract).
+ */
+export declare const ControlHarnessSettingsPatch: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    defaultModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>>;
+    maxTurns: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxRounds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    toolsAllow: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    toolsDeny: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    fallbackModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    web: z.ZodOptional<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+    authPreference: z.ZodOptional<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+}, "strict", z.ZodTypeAny, {
+    web?: "off" | "auto" | "cached" | "live" | undefined;
+    enabled?: boolean | undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+    maxUsd?: number | null | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    defaultModel?: string | null | undefined;
+    maxTurns?: number | null | undefined;
+    maxRounds?: number | null | undefined;
+    toolsAllow?: string[] | undefined;
+    toolsDeny?: string[] | undefined;
+    fallbackModel?: string | null | undefined;
+}, {
+    web?: "off" | "auto" | "cached" | "live" | undefined;
+    enabled?: boolean | undefined;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+    maxUsd?: number | null | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    defaultModel?: string | null | undefined;
+    maxTurns?: number | null | undefined;
+    maxRounds?: number | null | undefined;
+    toolsAllow?: string[] | undefined;
+    toolsDeny?: string[] | undefined;
+    fallbackModel?: string | null | undefined;
+}>;
+export type ControlHarnessSettingsPatch = z.infer<typeof ControlHarnessSettingsPatch>;
+export declare const ControlSettingsUpdateRequest: z.ZodEffects<z.ZodObject<{
+    defaultPortfolio: z.ZodOptional<z.ZodEnum<["daily-rich", "balanced", "cheapest", "strongest", "burn", "subscription-first", "api-overflow", "conserve-claude", "conserve-codex"]>>;
+    interactionTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    routingPolicy: z.ZodOptional<z.ZodEnum<["auto", "primary"]>>;
+    primaryHarness: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    eligibleHarnesses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    envInheritance: z.ZodOptional<z.ZodEnum<["mirror_native", "clean"]>>;
+    maxUsdPerRun: z.ZodOptional<z.ZodNumber>;
+    clearMaxUsdPerRun: z.ZodOptional<z.ZodBoolean>;
+    authPreference: z.ZodOptional<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+    harnesses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        defaultModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>>;
+        maxTurns: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxRounds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        toolsAllow: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        toolsDeny: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        fallbackModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        web: z.ZodOptional<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+        authPreference: z.ZodOptional<z.ZodEnum<["subscription", "api_key", "auto"]>>;
+    }, "strict", z.ZodTypeAny, {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        enabled?: boolean | undefined;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+        maxUsd?: number | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        defaultModel?: string | null | undefined;
+        maxTurns?: number | null | undefined;
+        maxRounds?: number | null | undefined;
+        toolsAllow?: string[] | undefined;
+        toolsDeny?: string[] | undefined;
+        fallbackModel?: string | null | undefined;
+    }, {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        enabled?: boolean | undefined;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+        maxUsd?: number | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        defaultModel?: string | null | undefined;
+        maxTurns?: number | null | undefined;
+        maxRounds?: number | null | undefined;
+        toolsAllow?: string[] | undefined;
+        toolsDeny?: string[] | undefined;
+        fallbackModel?: string | null | undefined;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    harnesses?: Record<string, {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        enabled?: boolean | undefined;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+        maxUsd?: number | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        defaultModel?: string | null | undefined;
+        maxTurns?: number | null | undefined;
+        maxRounds?: number | null | undefined;
+        toolsAllow?: string[] | undefined;
+        toolsDeny?: string[] | undefined;
+        fallbackModel?: string | null | undefined;
+    }> | undefined;
+    primaryHarness?: string | null | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    eligibleHarnesses?: string[] | undefined;
+    defaultPortfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    interactionTimeoutMs?: number | undefined;
+    envInheritance?: "mirror_native" | "clean" | undefined;
+    maxUsdPerRun?: number | undefined;
+    routingPolicy?: "auto" | "primary" | undefined;
+    clearMaxUsdPerRun?: boolean | undefined;
+}, {
+    harnesses?: Record<string, {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        enabled?: boolean | undefined;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+        maxUsd?: number | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        defaultModel?: string | null | undefined;
+        maxTurns?: number | null | undefined;
+        maxRounds?: number | null | undefined;
+        toolsAllow?: string[] | undefined;
+        toolsDeny?: string[] | undefined;
+        fallbackModel?: string | null | undefined;
+    }> | undefined;
+    primaryHarness?: string | null | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    eligibleHarnesses?: string[] | undefined;
+    defaultPortfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    interactionTimeoutMs?: number | undefined;
+    envInheritance?: "mirror_native" | "clean" | undefined;
+    maxUsdPerRun?: number | undefined;
+    routingPolicy?: "auto" | "primary" | undefined;
+    clearMaxUsdPerRun?: boolean | undefined;
+}>, {
+    harnesses?: Record<string, {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        enabled?: boolean | undefined;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+        maxUsd?: number | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        defaultModel?: string | null | undefined;
+        maxTurns?: number | null | undefined;
+        maxRounds?: number | null | undefined;
+        toolsAllow?: string[] | undefined;
+        toolsDeny?: string[] | undefined;
+        fallbackModel?: string | null | undefined;
+    }> | undefined;
+    primaryHarness?: string | null | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    eligibleHarnesses?: string[] | undefined;
+    defaultPortfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    interactionTimeoutMs?: number | undefined;
+    envInheritance?: "mirror_native" | "clean" | undefined;
+    maxUsdPerRun?: number | undefined;
+    routingPolicy?: "auto" | "primary" | undefined;
+    clearMaxUsdPerRun?: boolean | undefined;
+}, {
+    harnesses?: Record<string, {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        enabled?: boolean | undefined;
+        effort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+        maxUsd?: number | null | undefined;
+        authPreference?: "auto" | "subscription" | "api_key" | undefined;
+        defaultModel?: string | null | undefined;
+        maxTurns?: number | null | undefined;
+        maxRounds?: number | null | undefined;
+        toolsAllow?: string[] | undefined;
+        toolsDeny?: string[] | undefined;
+        fallbackModel?: string | null | undefined;
+    }> | undefined;
+    primaryHarness?: string | null | undefined;
+    authPreference?: "auto" | "subscription" | "api_key" | undefined;
+    eligibleHarnesses?: string[] | undefined;
+    defaultPortfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    interactionTimeoutMs?: number | undefined;
+    envInheritance?: "mirror_native" | "clean" | undefined;
+    maxUsdPerRun?: number | undefined;
+    routingPolicy?: "auto" | "primary" | undefined;
+    clearMaxUsdPerRun?: boolean | undefined;
+}>;
+export type ControlSettingsUpdateRequest = z.infer<typeof ControlSettingsUpdateRequest>;
+/** Secret list row: exactly what the store's list() can honestly produce
+ * (the never-populated harnesses/env/description fields were retired in the
+ * v0.15 triage). */
+export declare const SecretMetadata: z.ZodObject<{
+    name: z.ZodString;
+    backend: z.ZodEnum<["keychain", "file"]>;
+    present: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    backend: "file" | "keychain";
+    present: boolean;
+}, {
+    name: string;
+    backend: "file" | "keychain";
+    present?: boolean | undefined;
+}>;
+export type SecretMetadata = z.infer<typeof SecretMetadata>;
+export declare const ControlSecretListResponse: z.ZodObject<{
+    backend: z.ZodEnum<["keychain", "file"]>;
+    secrets: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        backend: z.ZodEnum<["keychain", "file"]>;
+        present: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        backend: "file" | "keychain";
+        present: boolean;
+    }, {
+        name: string;
+        backend: "file" | "keychain";
+        present?: boolean | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    backend: "file" | "keychain";
+    secrets: {
+        name: string;
+        backend: "file" | "keychain";
+        present: boolean;
+    }[];
+}, {
+    backend: "file" | "keychain";
+    secrets?: {
+        name: string;
+        backend: "file" | "keychain";
+        present?: boolean | undefined;
+    }[] | undefined;
+}>;
+export type ControlSecretListResponse = z.infer<typeof ControlSecretListResponse>;
+//# sourceMappingURL=control.d.ts.map