npm - @tokensize/agent-router - Versions diffs - 0.3.0-beta.0 - Mend

@tokensize/agent-router 0.3.0-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.d.cts ADDED Viewed

@@ -0,0 +1,1464 @@
+import { z } from 'zod';
+declare const AGENT_ROUTER_SCHEMA_VERSION: 2;
+declare const AGENT_ROUTER_VERSION = "2026-07-20-allowance-aware-v2";
+declare const harnessIdSchema: z.ZodEnum<{
+    codex: "codex";
+    claude: "claude";
+    copilot: "copilot";
+    cursor: "cursor";
+    opencode: "opencode";
+    custom: "custom";
+}>;
+declare const readinessSchema: z.ZodEnum<{
+    installed: "installed";
+    "auth-ready": "auth-ready";
+    "model-listed": "model-listed";
+    "invocation-compatible": "invocation-compatible";
+    "live-confirmed": "live-confirmed";
+}>;
+declare const permissionProfileSchema: z.ZodEnum<{
+    inspect: "inspect";
+    edit: "edit";
+    test: "test";
+    network: "network";
+}>;
+declare const taskRoleSchema: z.ZodEnum<{
+    inspect: "inspect";
+    test: "test";
+    plan: "plan";
+    implement: "implement";
+    review: "review";
+}>;
+declare const taskTypeSchema: z.ZodEnum<{
+    test: "test";
+    review: "review";
+    bug: "bug";
+    feature: "feature";
+    refactor: "refactor";
+    migration: "migration";
+    research: "research";
+    docs: "docs";
+    unknown: "unknown";
+}>;
+declare const routingObjectiveSchema: z.ZodEnum<{
+    quality: "quality";
+    balanced: "balanced";
+    tokens: "tokens";
+    latency: "latency";
+}>;
+declare const clientSurfaceSchema: z.ZodEnum<{
+    cli: "cli";
+    skill: "skill";
+    "codex-plugin": "codex-plugin";
+    "opencode-plugin": "opencode-plugin";
+}>;
+/**
+ * A privacy-safe, point-in-time view of a local harness allowance. Clients
+ * derive this through the harness's supported status interface and discard the
+ * raw account response. It is routing metadata, never a credential or bill.
+ */
+declare const allowanceSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        available: "available";
+        low: "low";
+        exhausted: "exhausted";
+        unmetered: "unmetered";
+    }>;
+    remainingFraction: z.ZodOptional<z.ZodNumber>;
+    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+    observedAt: z.ZodISODateTime;
+    source: z.ZodEnum<{
+        "runtime-reported": "runtime-reported";
+        "credential-free": "credential-free";
+        unavailable: "unavailable";
+    }>;
+}, z.core.$strip>;
+declare const agentModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    harness: z.ZodEnum<{
+        codex: "codex";
+        claude: "claude";
+        copilot: "copilot";
+        cursor: "cursor";
+        opencode: "opencode";
+        custom: "custom";
+    }>;
+    nativeModelId: z.ZodString;
+    displayName: z.ZodString;
+    readiness: z.ZodEnum<{
+        installed: "installed";
+        "auth-ready": "auth-ready";
+        "model-listed": "model-listed";
+        "invocation-compatible": "invocation-compatible";
+        "live-confirmed": "live-confirmed";
+    }>;
+    authMode: z.ZodEnum<{
+        unknown: "unknown";
+        subscription: "subscription";
+        "api-key": "api-key";
+        "cloud-provider": "cloud-provider";
+        local: "local";
+    }>;
+    productUseApproved: z.ZodBoolean;
+    capabilities: z.ZodObject<{
+        tools: z.ZodBoolean;
+        vision: z.ZodBoolean;
+        structuredOutput: z.ZodEnum<{
+            none: "none";
+            json: "json";
+            jsonl: "jsonl";
+            schema: "schema";
+        }>;
+        sessions: z.ZodEnum<{
+            none: "none";
+            resume: "resume";
+            continue: "continue";
+        }>;
+        permissions: z.ZodArray<z.ZodEnum<{
+            inspect: "inspect";
+            edit: "edit";
+            test: "test";
+            network: "network";
+        }>>;
+    }, z.core.$strip>;
+    identityProof: z.ZodEnum<{
+        "runtime-reported": "runtime-reported";
+        unavailable: "unavailable";
+        requested: "requested";
+    }>;
+    qualityPrior: z.ZodNumber;
+    tokenEfficiencyPrior: z.ZodNumber;
+    latencyPrior: z.ZodNumber;
+    allowance: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            available: "available";
+            low: "low";
+            exhausted: "exhausted";
+            unmetered: "unmetered";
+        }>;
+        remainingFraction: z.ZodOptional<z.ZodNumber>;
+        resetsAt: z.ZodOptional<z.ZodISODateTime>;
+        observedAt: z.ZodISODateTime;
+        source: z.ZodEnum<{
+            "runtime-reported": "runtime-reported";
+            "credential-free": "credential-free";
+            unavailable: "unavailable";
+        }>;
+    }, z.core.$strip>>;
+    localHistory: z.ZodOptional<z.ZodObject<{
+        verifiedRuns: z.ZodNumber;
+        successRate: z.ZodNumber;
+        medianTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const agentTaskFeaturesSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        inspect: "inspect";
+        test: "test";
+        plan: "plan";
+        implement: "implement";
+        review: "review";
+    }>;
+    type: z.ZodEnum<{
+        test: "test";
+        review: "review";
+        bug: "bug";
+        feature: "feature";
+        refactor: "refactor";
+        migration: "migration";
+        research: "research";
+        docs: "docs";
+        unknown: "unknown";
+    }>;
+    complexity: z.ZodNumber;
+    scopeBreadth: z.ZodNumber;
+    contextTokens: z.ZodNumber;
+    oracleStrength: z.ZodNumber;
+    codeDensity: z.ZodNumber;
+    risk: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
+    languages: z.ZodArray<z.ZodString>;
+    requiredTools: z.ZodArray<z.ZodString>;
+    requiresVision: z.ZodBoolean;
+    requiresNetwork: z.ZodBoolean;
+    cacheHit: z.ZodBoolean;
+}, z.core.$strip>;
+declare const agentRouteRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    client: z.ZodObject<{
+        surface: z.ZodEnum<{
+            cli: "cli";
+            skill: "skill";
+            "codex-plugin": "codex-plugin";
+            "opencode-plugin": "opencode-plugin";
+        }>;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    requestId: z.ZodUUID;
+    installationId: z.ZodString;
+    routerMode: z.ZodEnum<{
+        "metadata-only": "metadata-only";
+        "prompt-assisted": "prompt-assisted";
+    }>;
+    task: z.ZodObject<{
+        role: z.ZodEnum<{
+            inspect: "inspect";
+            test: "test";
+            plan: "plan";
+            implement: "implement";
+            review: "review";
+        }>;
+        type: z.ZodEnum<{
+            test: "test";
+            review: "review";
+            bug: "bug";
+            feature: "feature";
+            refactor: "refactor";
+            migration: "migration";
+            research: "research";
+            docs: "docs";
+            unknown: "unknown";
+        }>;
+        complexity: z.ZodNumber;
+        scopeBreadth: z.ZodNumber;
+        contextTokens: z.ZodNumber;
+        oracleStrength: z.ZodNumber;
+        codeDensity: z.ZodNumber;
+        risk: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        languages: z.ZodArray<z.ZodString>;
+        requiredTools: z.ZodArray<z.ZodString>;
+        requiresVision: z.ZodBoolean;
+        requiresNetwork: z.ZodBoolean;
+        cacheHit: z.ZodBoolean;
+    }, z.core.$strip>;
+    prompt: z.ZodOptional<z.ZodString>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        harness: z.ZodEnum<{
+            codex: "codex";
+            claude: "claude";
+            copilot: "copilot";
+            cursor: "cursor";
+            opencode: "opencode";
+            custom: "custom";
+        }>;
+        nativeModelId: z.ZodString;
+        displayName: z.ZodString;
+        readiness: z.ZodEnum<{
+            installed: "installed";
+            "auth-ready": "auth-ready";
+            "model-listed": "model-listed";
+            "invocation-compatible": "invocation-compatible";
+            "live-confirmed": "live-confirmed";
+        }>;
+        authMode: z.ZodEnum<{
+            unknown: "unknown";
+            subscription: "subscription";
+            "api-key": "api-key";
+            "cloud-provider": "cloud-provider";
+            local: "local";
+        }>;
+        productUseApproved: z.ZodBoolean;
+        capabilities: z.ZodObject<{
+            tools: z.ZodBoolean;
+            vision: z.ZodBoolean;
+            structuredOutput: z.ZodEnum<{
+                none: "none";
+                json: "json";
+                jsonl: "jsonl";
+                schema: "schema";
+            }>;
+            sessions: z.ZodEnum<{
+                none: "none";
+                resume: "resume";
+                continue: "continue";
+            }>;
+            permissions: z.ZodArray<z.ZodEnum<{
+                inspect: "inspect";
+                edit: "edit";
+                test: "test";
+                network: "network";
+            }>>;
+        }, z.core.$strip>;
+        identityProof: z.ZodEnum<{
+            "runtime-reported": "runtime-reported";
+            unavailable: "unavailable";
+            requested: "requested";
+        }>;
+        qualityPrior: z.ZodNumber;
+        tokenEfficiencyPrior: z.ZodNumber;
+        latencyPrior: z.ZodNumber;
+        allowance: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                available: "available";
+                low: "low";
+                exhausted: "exhausted";
+                unmetered: "unmetered";
+            }>;
+            remainingFraction: z.ZodOptional<z.ZodNumber>;
+            resetsAt: z.ZodOptional<z.ZodISODateTime>;
+            observedAt: z.ZodISODateTime;
+            source: z.ZodEnum<{
+                "runtime-reported": "runtime-reported";
+                "credential-free": "credential-free";
+                unavailable: "unavailable";
+            }>;
+        }, z.core.$strip>>;
+        localHistory: z.ZodOptional<z.ZodObject<{
+            verifiedRuns: z.ZodNumber;
+            successRate: z.ZodNumber;
+            medianTokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    root: z.ZodObject<{
+        harness: z.ZodEnum<{
+            codex: "codex";
+            claude: "claude";
+            copilot: "copilot";
+            cursor: "cursor";
+            opencode: "opencode";
+            custom: "custom";
+        }>;
+        active: z.ZodBoolean;
+        modelId: z.ZodOptional<z.ZodString>;
+        qualityPrior: z.ZodDefault<z.ZodNumber>;
+        allowance: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                available: "available";
+                low: "low";
+                exhausted: "exhausted";
+                unmetered: "unmetered";
+            }>;
+            remainingFraction: z.ZodOptional<z.ZodNumber>;
+            resetsAt: z.ZodOptional<z.ZodISODateTime>;
+            observedAt: z.ZodISODateTime;
+            source: z.ZodEnum<{
+                "runtime-reported": "runtime-reported";
+                "credential-free": "credential-free";
+                unavailable: "unavailable";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    policy: z.ZodObject<{
+        objective: z.ZodEnum<{
+            quality: "quality";
+            balanced: "balanced";
+            tokens: "tokens";
+            latency: "latency";
+        }>;
+        maxDelegationDepth: z.ZodNumber;
+        delegationDepth: z.ZodNumber;
+        allowedHarnesses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            codex: "codex";
+            claude: "claude";
+            copilot: "copilot";
+            cursor: "cursor";
+            opencode: "opencode";
+            custom: "custom";
+        }>>>;
+        permissionCeiling: z.ZodEnum<{
+            inspect: "inspect";
+            edit: "edit";
+            test: "test";
+            network: "network";
+        }>;
+        tokenBudget: z.ZodOptional<z.ZodNumber>;
+        wallTimeBudgetMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const workflowSchema: z.ZodEnum<{
+    "root-only": "root-only";
+    "single-inspector": "single-inspector";
+    "single-implementer": "single-implementer";
+    "implementer-deterministic-verify": "implementer-deterministic-verify";
+    "implementer-independent-review": "implementer-independent-review";
+}>;
+declare const executionPlanSchema: z.ZodObject<{
+    workflow: z.ZodEnum<{
+        "root-only": "root-only";
+        "single-inspector": "single-inspector";
+        "single-implementer": "single-implementer";
+        "implementer-deterministic-verify": "implementer-deterministic-verify";
+        "implementer-independent-review": "implementer-independent-review";
+    }>;
+    targetId: z.ZodNullable<z.ZodString>;
+    permissionProfile: z.ZodEnum<{
+        inspect: "inspect";
+        edit: "edit";
+        test: "test";
+        network: "network";
+    }>;
+    maxWallMs: z.ZodNumber;
+    maxTurns: z.ZodNumber;
+    requiresWorktree: z.ZodBoolean;
+}, z.core.$strip>;
+declare const agentRouteResponseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    requestId: z.ZodUUID;
+    routeId: z.ZodUUID;
+    routerVersion: z.ZodString;
+    expiresAt: z.ZodISODateTime;
+    plan: z.ZodObject<{
+        workflow: z.ZodEnum<{
+            "root-only": "root-only";
+            "single-inspector": "single-inspector";
+            "single-implementer": "single-implementer";
+            "implementer-deterministic-verify": "implementer-deterministic-verify";
+            "implementer-independent-review": "implementer-independent-review";
+        }>;
+        targetId: z.ZodNullable<z.ZodString>;
+        permissionProfile: z.ZodEnum<{
+            inspect: "inspect";
+            edit: "edit";
+            test: "test";
+            network: "network";
+        }>;
+        maxWallMs: z.ZodNumber;
+        maxTurns: z.ZodNumber;
+        requiresWorktree: z.ZodBoolean;
+    }, z.core.$strip>;
+    fallback: z.ZodObject<{
+        workflow: z.ZodEnum<{
+            "root-only": "root-only";
+            "single-inspector": "single-inspector";
+            "single-implementer": "single-implementer";
+            "implementer-deterministic-verify": "implementer-deterministic-verify";
+            "implementer-independent-review": "implementer-independent-review";
+        }>;
+        targetId: z.ZodNullable<z.ZodString>;
+        permissionProfile: z.ZodEnum<{
+            inspect: "inspect";
+            edit: "edit";
+            test: "test";
+            network: "network";
+        }>;
+        maxWallMs: z.ZodNumber;
+        maxTurns: z.ZodNumber;
+        requiresWorktree: z.ZodBoolean;
+    }, z.core.$strip>;
+    confidence: z.ZodNumber;
+    reasonCodes: z.ZodArray<z.ZodString>;
+    expected: z.ZodObject<{
+        verifiedSuccess: z.ZodNumber;
+        contextTokens: z.ZodNumber;
+        wallTimeMs: z.ZodNumber;
+    }, z.core.$strip>;
+    feedbackToken: z.ZodString;
+}, z.core.$strip>;
+declare const agentFeedbackSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    routeId: z.ZodUUID;
+    feedbackToken: z.ZodString;
+    idempotencyKey: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        verified: "verified";
+        failed: "failed";
+        blocked: "blocked";
+        cancelled: "cancelled";
+    }>;
+    confirmedTargetId: z.ZodNullable<z.ZodString>;
+    identityConfirmed: z.ZodBoolean;
+    checksPassed: z.ZodNumber;
+    checksFailed: z.ZodNumber;
+    retries: z.ZodNumber;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        contextTokensEstimated: z.ZodNumber;
+        source: z.ZodEnum<{
+            unknown: "unknown";
+            reported: "reported";
+            estimated: "estimated";
+        }>;
+    }, z.core.$strip>;
+    timings: z.ZodObject<{
+        totalMs: z.ZodNumber;
+        routingMs: z.ZodNumber;
+        executionMs: z.ZodNumber;
+        verificationMs: z.ZodNumber;
+    }, z.core.$strip>;
+    failureCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type HarnessId = z.infer<typeof harnessIdSchema>;
+type ClientSurface = z.infer<typeof clientSurfaceSchema>;
+type Readiness = z.infer<typeof readinessSchema>;
+type PermissionProfile = z.infer<typeof permissionProfileSchema>;
+type TaskRole = z.infer<typeof taskRoleSchema>;
+type RoutingObjective = z.infer<typeof routingObjectiveSchema>;
+type Allowance = z.infer<typeof allowanceSchema>;
+type AgentModel = z.infer<typeof agentModelSchema>;
+type AgentTaskFeatures = z.infer<typeof agentTaskFeaturesSchema>;
+type AgentRouteRequest = z.infer<typeof agentRouteRequestSchema>;
+type ExecutionPlan = z.infer<typeof executionPlanSchema>;
+type AgentRouteResponse = z.infer<typeof agentRouteResponseSchema>;
+type AgentFeedback = z.infer<typeof agentFeedbackSchema>;
+interface FeaturizeAgentTaskInput {
+    task: string;
+    role?: AgentTaskFeatures["role"];
+    permissionProfile?: "inspect" | "edit" | "test" | "network";
+    languages?: string[];
+    requiredTools?: string[];
+    contextTokens?: number;
+    scopePaths?: string[];
+    acceptance?: string[];
+}
+declare function featurizeAgentTask(input: FeaturizeAgentTaskInput): AgentTaskFeatures;
+interface RouteSelection {
+    plan: ExecutionPlan;
+    fallback: ExecutionPlan;
+    confidence: number;
+    reasonCodes: string[];
+    expected: {
+        verifiedSuccess: number;
+        contextTokens: number;
+        wallTimeMs: number;
+    };
+}
+declare function selectAgentRoute(request: AgentRouteRequest): RouteSelection;
+/**
+ * The Run document: one durable, addressable record per routed task. The Run
+ * owns the run — chat transcripts, CLI output, and dashboards are views. Every
+ * hand (router, root agent, delegate harness, human) appends typed events; the
+ * status is derived from the event log, never stored independently.
+ *
+ * Content rule: no prompt text, code, diffs, model output, repository paths,
+ * or raw installation identifiers may enter a Run. Every payload field is an
+ * enum, number, boolean, identifier, or bounded machine-generated code, and
+ * every object is strict so an unexpected free-text field is a schema error.
+ */
+declare const RUN_SCHEMA_VERSION: 3;
+declare const runStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+    planned: "planned";
+    "awaiting-approval": "awaiting-approval";
+    executing: "executing";
+    verifying: "verifying";
+    expired: "expired";
+}>;
+declare const runActorSchema: z.ZodEnum<{
+    router: "router";
+    "root-agent": "root-agent";
+    delegate: "delegate";
+    human: "human";
+    system: "system";
+}>;
+declare const approvalKindSchema: z.ZodEnum<{
+    "subscription-use": "subscription-use";
+    execute: "execute";
+    "share-prompt": "share-prompt";
+}>;
+declare const approvalSurfaceSchema: z.ZodEnum<{
+    "local-cli": "local-cli";
+    web: "web";
+}>;
+declare const runEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"created">;
+    data: z.ZodObject<{
+        surface: z.ZodEnum<{
+            cli: "cli";
+            skill: "skill";
+            "codex-plugin": "codex-plugin";
+            "opencode-plugin": "opencode-plugin";
+        }>;
+        routerMode: z.ZodEnum<{
+            "metadata-only": "metadata-only";
+            "prompt-assisted": "prompt-assisted";
+        }>;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"routed">;
+    data: z.ZodObject<{
+        targetId: z.ZodNullable<z.ZodString>;
+        workflow: z.ZodEnum<{
+            "root-only": "root-only";
+            "single-inspector": "single-inspector";
+            "single-implementer": "single-implementer";
+            "implementer-deterministic-verify": "implementer-deterministic-verify";
+            "implementer-independent-review": "implementer-independent-review";
+        }>;
+        confidence: z.ZodNumber;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"approval-requested">;
+    data: z.ZodObject<{
+        kind: z.ZodEnum<{
+            "subscription-use": "subscription-use";
+            execute: "execute";
+            "share-prompt": "share-prompt";
+        }>;
+        harness: z.ZodOptional<z.ZodEnum<{
+            codex: "codex";
+            claude: "claude";
+            copilot: "copilot";
+            cursor: "cursor";
+            opencode: "opencode";
+            custom: "custom";
+        }>>;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"approval-granted">;
+    data: z.ZodObject<{
+        kind: z.ZodEnum<{
+            "subscription-use": "subscription-use";
+            execute: "execute";
+            "share-prompt": "share-prompt";
+        }>;
+        grantedBy: z.ZodEnum<{
+            "local-cli": "local-cli";
+            web: "web";
+        }>;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"approval-denied">;
+    data: z.ZodObject<{
+        kind: z.ZodEnum<{
+            "subscription-use": "subscription-use";
+            execute: "execute";
+            "share-prompt": "share-prompt";
+        }>;
+        deniedBy: z.ZodEnum<{
+            "local-cli": "local-cli";
+            web: "web";
+        }>;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"execution-started">;
+    data: z.ZodObject<{
+        targetId: z.ZodString;
+        permissionProfile: z.ZodEnum<{
+            inspect: "inspect";
+            edit: "edit";
+            test: "test";
+            network: "network";
+        }>;
+        worktree: z.ZodBoolean;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"execution-progress">;
+    data: z.ZodObject<{
+        turn: z.ZodNumber;
+        elapsedMs: z.ZodNumber;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"execution-finished">;
+    data: z.ZodObject<{
+        outcome: z.ZodEnum<{
+            success: "success";
+            failure: "failure";
+            timeout: "timeout";
+        }>;
+        failureCode: z.ZodOptional<z.ZodString>;
+        elapsedMs: z.ZodNumber;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodOptional<z.ZodNumber>;
+            outputTokens: z.ZodOptional<z.ZodNumber>;
+            contextTokensEstimated: z.ZodNumber;
+            source: z.ZodEnum<{
+                unknown: "unknown";
+                reported: "reported";
+                estimated: "estimated";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"verification-started">;
+    data: z.ZodObject<{}, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"verification-finished">;
+    data: z.ZodObject<{
+        passed: z.ZodBoolean;
+        checksPassed: z.ZodNumber;
+        checksFailed: z.ZodNumber;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"feedback">;
+    data: z.ZodObject<{
+        status: z.ZodEnum<{
+            completed: "completed";
+            verified: "verified";
+            failed: "failed";
+            blocked: "blocked";
+            cancelled: "cancelled";
+        }>;
+        rating: z.ZodOptional<z.ZodNumber>;
+        modelChoice: z.ZodOptional<z.ZodEnum<{
+            right: "right";
+            acceptable: "acceptable";
+            wrong: "wrong";
+        }>>;
+        wouldUseAgain: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"cancelled">;
+    data: z.ZodObject<{
+        by: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"expired">;
+    data: z.ZodObject<{}, z.core.$strict>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+    actor: z.ZodEnum<{
+        router: "router";
+        "root-agent": "root-agent";
+        delegate: "delegate";
+        human: "human";
+        system: "system";
+    }>;
+}, z.core.$strict>], "type">;
+type RunStatus = z.infer<typeof runStatusSchema>;
+type RunActor = z.infer<typeof runActorSchema>;
+type RunEvent = z.infer<typeof runEventSchema>;
+type RunEventType = RunEvent["type"];
+type ApprovalKind = z.infer<typeof approvalKindSchema>;
+/** Candidate snapshot persisted with a Run: capability metadata only, never allowance or local history. */
+declare const runCandidateSchema: z.ZodObject<{
+    id: z.ZodString;
+    harness: z.ZodEnum<{
+        codex: "codex";
+        claude: "claude";
+        copilot: "copilot";
+        cursor: "cursor";
+        opencode: "opencode";
+        custom: "custom";
+    }>;
+    nativeModelId: z.ZodString;
+    readiness: z.ZodEnum<{
+        installed: "installed";
+        "auth-ready": "auth-ready";
+        "model-listed": "model-listed";
+        "invocation-compatible": "invocation-compatible";
+        "live-confirmed": "live-confirmed";
+    }>;
+    authMode: z.ZodEnum<{
+        unknown: "unknown";
+        subscription: "subscription";
+        "api-key": "api-key";
+        "cloud-provider": "cloud-provider";
+        local: "local";
+    }>;
+    productUseApproved: z.ZodBoolean;
+    capabilities: z.ZodObject<{
+        tools: z.ZodBoolean;
+        vision: z.ZodBoolean;
+        structuredOutput: z.ZodEnum<{
+            none: "none";
+            json: "json";
+            jsonl: "jsonl";
+            schema: "schema";
+        }>;
+        sessions: z.ZodEnum<{
+            none: "none";
+            resume: "resume";
+            continue: "continue";
+        }>;
+        permissions: z.ZodArray<z.ZodEnum<{
+            inspect: "inspect";
+            edit: "edit";
+            test: "test";
+            network: "network";
+        }>>;
+    }, z.core.$strip>;
+    identityProof: z.ZodEnum<{
+        "runtime-reported": "runtime-reported";
+        unavailable: "unavailable";
+        requested: "requested";
+    }>;
+    qualityPrior: z.ZodNumber;
+    tokenEfficiencyPrior: z.ZodNumber;
+    latencyPrior: z.ZodNumber;
+}, z.core.$strict>;
+declare const effectivePolicySchema: z.ZodObject<{
+    objective: z.ZodEnum<{
+        quality: "quality";
+        balanced: "balanced";
+        tokens: "tokens";
+        latency: "latency";
+    }>;
+    maxDelegationDepth: z.ZodNumber;
+    permissionCeiling: z.ZodEnum<{
+        inspect: "inspect";
+        edit: "edit";
+        test: "test";
+        network: "network";
+    }>;
+    allowedHarnesses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        codex: "codex";
+        claude: "claude";
+        copilot: "copilot";
+        cursor: "cursor";
+        opencode: "opencode";
+        custom: "custom";
+    }>>>;
+    tokenBudget: z.ZodOptional<z.ZodNumber>;
+    wallTimeBudgetMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const runApprovalSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "subscription-use": "subscription-use";
+        execute: "execute";
+        "share-prompt": "share-prompt";
+    }>;
+    state: z.ZodEnum<{
+        pending: "pending";
+        granted: "granted";
+        denied: "denied";
+    }>;
+    surface: z.ZodOptional<z.ZodEnum<{
+        "local-cli": "local-cli";
+        web: "web";
+    }>>;
+    at: z.ZodISODateTime;
+}, z.core.$strict>;
+declare const runDocumentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<3>;
+    runId: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    origin: z.ZodObject<{
+        surface: z.ZodEnum<{
+            cli: "cli";
+            skill: "skill";
+            "codex-plugin": "codex-plugin";
+            "opencode-plugin": "opencode-plugin";
+        }>;
+        clientVersion: z.ZodString;
+    }, z.core.$strict>;
+    task: z.ZodObject<{
+        role: z.ZodEnum<{
+            inspect: "inspect";
+            test: "test";
+            plan: "plan";
+            implement: "implement";
+            review: "review";
+        }>;
+        type: z.ZodEnum<{
+            test: "test";
+            review: "review";
+            bug: "bug";
+            feature: "feature";
+            refactor: "refactor";
+            migration: "migration";
+            research: "research";
+            docs: "docs";
+            unknown: "unknown";
+        }>;
+        complexity: z.ZodNumber;
+        scopeBreadth: z.ZodNumber;
+        contextTokens: z.ZodNumber;
+        oracleStrength: z.ZodNumber;
+        codeDensity: z.ZodNumber;
+        risk: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        languages: z.ZodArray<z.ZodString>;
+        requiredTools: z.ZodArray<z.ZodString>;
+        requiresVision: z.ZodBoolean;
+        requiresNetwork: z.ZodBoolean;
+        cacheHit: z.ZodBoolean;
+    }, z.core.$strip>;
+    candidatesSnapshot: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        harness: z.ZodEnum<{
+            codex: "codex";
+            claude: "claude";
+            copilot: "copilot";
+            cursor: "cursor";
+            opencode: "opencode";
+            custom: "custom";
+        }>;
+        nativeModelId: z.ZodString;
+        readiness: z.ZodEnum<{
+            installed: "installed";
+            "auth-ready": "auth-ready";
+            "model-listed": "model-listed";
+            "invocation-compatible": "invocation-compatible";
+            "live-confirmed": "live-confirmed";
+        }>;
+        authMode: z.ZodEnum<{
+            unknown: "unknown";
+            subscription: "subscription";
+            "api-key": "api-key";
+            "cloud-provider": "cloud-provider";
+            local: "local";
+        }>;
+        productUseApproved: z.ZodBoolean;
+        capabilities: z.ZodObject<{
+            tools: z.ZodBoolean;
+            vision: z.ZodBoolean;
+            structuredOutput: z.ZodEnum<{
+                none: "none";
+                json: "json";
+                jsonl: "jsonl";
+                schema: "schema";
+            }>;
+            sessions: z.ZodEnum<{
+                none: "none";
+                resume: "resume";
+                continue: "continue";
+            }>;
+            permissions: z.ZodArray<z.ZodEnum<{
+                inspect: "inspect";
+                edit: "edit";
+                test: "test";
+                network: "network";
+            }>>;
+        }, z.core.$strip>;
+        identityProof: z.ZodEnum<{
+            "runtime-reported": "runtime-reported";
+            unavailable: "unavailable";
+            requested: "requested";
+        }>;
+        qualityPrior: z.ZodNumber;
+        tokenEfficiencyPrior: z.ZodNumber;
+        latencyPrior: z.ZodNumber;
+    }, z.core.$strict>>;
+    decision: z.ZodObject<{
+        plan: z.ZodObject<{
+            workflow: z.ZodEnum<{
+                "root-only": "root-only";
+                "single-inspector": "single-inspector";
+                "single-implementer": "single-implementer";
+                "implementer-deterministic-verify": "implementer-deterministic-verify";
+                "implementer-independent-review": "implementer-independent-review";
+            }>;
+            targetId: z.ZodNullable<z.ZodString>;
+            permissionProfile: z.ZodEnum<{
+                inspect: "inspect";
+                edit: "edit";
+                test: "test";
+                network: "network";
+            }>;
+            maxWallMs: z.ZodNumber;
+            maxTurns: z.ZodNumber;
+            requiresWorktree: z.ZodBoolean;
+        }, z.core.$strip>;
+        fallback: z.ZodObject<{
+            workflow: z.ZodEnum<{
+                "root-only": "root-only";
+                "single-inspector": "single-inspector";
+                "single-implementer": "single-implementer";
+                "implementer-deterministic-verify": "implementer-deterministic-verify";
+                "implementer-independent-review": "implementer-independent-review";
+            }>;
+            targetId: z.ZodNullable<z.ZodString>;
+            permissionProfile: z.ZodEnum<{
+                inspect: "inspect";
+                edit: "edit";
+                test: "test";
+                network: "network";
+            }>;
+            maxWallMs: z.ZodNumber;
+            maxTurns: z.ZodNumber;
+            requiresWorktree: z.ZodBoolean;
+        }, z.core.$strip>;
+        confidence: z.ZodNumber;
+        reasonCodes: z.ZodArray<z.ZodString>;
+        expected: z.ZodObject<{
+            verifiedSuccess: z.ZodNumber;
+            contextTokens: z.ZodNumber;
+            wallTimeMs: z.ZodNumber;
+        }, z.core.$strict>;
+        routerVersion: z.ZodString;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        objective: z.ZodEnum<{
+            quality: "quality";
+            balanced: "balanced";
+            tokens: "tokens";
+            latency: "latency";
+        }>;
+        maxDelegationDepth: z.ZodNumber;
+        permissionCeiling: z.ZodEnum<{
+            inspect: "inspect";
+            edit: "edit";
+            test: "test";
+            network: "network";
+        }>;
+        allowedHarnesses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            codex: "codex";
+            claude: "claude";
+            copilot: "copilot";
+            cursor: "cursor";
+            opencode: "opencode";
+            custom: "custom";
+        }>>>;
+        tokenBudget: z.ZodOptional<z.ZodNumber>;
+        wallTimeBudgetMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    approvals: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "subscription-use": "subscription-use";
+            execute: "execute";
+            "share-prompt": "share-prompt";
+        }>;
+        state: z.ZodEnum<{
+            pending: "pending";
+            granted: "granted";
+            denied: "denied";
+        }>;
+        surface: z.ZodOptional<z.ZodEnum<{
+            "local-cli": "local-cli";
+            web: "web";
+        }>>;
+        at: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"created">;
+        data: z.ZodObject<{
+            surface: z.ZodEnum<{
+                cli: "cli";
+                skill: "skill";
+                "codex-plugin": "codex-plugin";
+                "opencode-plugin": "opencode-plugin";
+            }>;
+            routerMode: z.ZodEnum<{
+                "metadata-only": "metadata-only";
+                "prompt-assisted": "prompt-assisted";
+            }>;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"routed">;
+        data: z.ZodObject<{
+            targetId: z.ZodNullable<z.ZodString>;
+            workflow: z.ZodEnum<{
+                "root-only": "root-only";
+                "single-inspector": "single-inspector";
+                "single-implementer": "single-implementer";
+                "implementer-deterministic-verify": "implementer-deterministic-verify";
+                "implementer-independent-review": "implementer-independent-review";
+            }>;
+            confidence: z.ZodNumber;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"approval-requested">;
+        data: z.ZodObject<{
+            kind: z.ZodEnum<{
+                "subscription-use": "subscription-use";
+                execute: "execute";
+                "share-prompt": "share-prompt";
+            }>;
+            harness: z.ZodOptional<z.ZodEnum<{
+                codex: "codex";
+                claude: "claude";
+                copilot: "copilot";
+                cursor: "cursor";
+                opencode: "opencode";
+                custom: "custom";
+            }>>;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"approval-granted">;
+        data: z.ZodObject<{
+            kind: z.ZodEnum<{
+                "subscription-use": "subscription-use";
+                execute: "execute";
+                "share-prompt": "share-prompt";
+            }>;
+            grantedBy: z.ZodEnum<{
+                "local-cli": "local-cli";
+                web: "web";
+            }>;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"approval-denied">;
+        data: z.ZodObject<{
+            kind: z.ZodEnum<{
+                "subscription-use": "subscription-use";
+                execute: "execute";
+                "share-prompt": "share-prompt";
+            }>;
+            deniedBy: z.ZodEnum<{
+                "local-cli": "local-cli";
+                web: "web";
+            }>;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"execution-started">;
+        data: z.ZodObject<{
+            targetId: z.ZodString;
+            permissionProfile: z.ZodEnum<{
+                inspect: "inspect";
+                edit: "edit";
+                test: "test";
+                network: "network";
+            }>;
+            worktree: z.ZodBoolean;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"execution-progress">;
+        data: z.ZodObject<{
+            turn: z.ZodNumber;
+            elapsedMs: z.ZodNumber;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"execution-finished">;
+        data: z.ZodObject<{
+            outcome: z.ZodEnum<{
+                success: "success";
+                failure: "failure";
+                timeout: "timeout";
+            }>;
+            failureCode: z.ZodOptional<z.ZodString>;
+            elapsedMs: z.ZodNumber;
+            usage: z.ZodOptional<z.ZodObject<{
+                inputTokens: z.ZodOptional<z.ZodNumber>;
+                outputTokens: z.ZodOptional<z.ZodNumber>;
+                contextTokensEstimated: z.ZodNumber;
+                source: z.ZodEnum<{
+                    unknown: "unknown";
+                    reported: "reported";
+                    estimated: "estimated";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"verification-started">;
+        data: z.ZodObject<{}, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"verification-finished">;
+        data: z.ZodObject<{
+            passed: z.ZodBoolean;
+            checksPassed: z.ZodNumber;
+            checksFailed: z.ZodNumber;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"feedback">;
+        data: z.ZodObject<{
+            status: z.ZodEnum<{
+                completed: "completed";
+                verified: "verified";
+                failed: "failed";
+                blocked: "blocked";
+                cancelled: "cancelled";
+            }>;
+            rating: z.ZodOptional<z.ZodNumber>;
+            modelChoice: z.ZodOptional<z.ZodEnum<{
+                right: "right";
+                acceptable: "acceptable";
+                wrong: "wrong";
+            }>>;
+            wouldUseAgain: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"cancelled">;
+        data: z.ZodObject<{
+            by: z.ZodEnum<{
+                router: "router";
+                "root-agent": "root-agent";
+                delegate: "delegate";
+                human: "human";
+                system: "system";
+            }>;
+        }, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"expired">;
+        data: z.ZodObject<{}, z.core.$strict>;
+        seq: z.ZodNumber;
+        at: z.ZodISODateTime;
+        actor: z.ZodEnum<{
+            router: "router";
+            "root-agent": "root-agent";
+            delegate: "delegate";
+            human: "human";
+            system: "system";
+        }>;
+    }, z.core.$strict>], "type">>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        planned: "planned";
+        "awaiting-approval": "awaiting-approval";
+        executing: "executing";
+        verifying: "verifying";
+        expired: "expired";
+    }>;
+    usage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        contextTokensEstimated: z.ZodNumber;
+        source: z.ZodEnum<{
+            unknown: "unknown";
+            reported: "reported";
+            estimated: "estimated";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type RunDocument = z.infer<typeof runDocumentSchema>;
+type EffectivePolicy = z.infer<typeof effectivePolicySchema>;
+type RunCandidate = z.infer<typeof runCandidateSchema>;
+type RunApproval = z.infer<typeof runApprovalSchema>;
+/** True when `event` may be appended to a run whose derived status is `status`. */
+declare function validateTransition(status: RunStatus | "none", event: Pick<RunEvent, "type">): boolean;
+/**
+ * Derive the run status from the full event log. Pure and total: any event
+ * list produces a status; invalid sequences should be rejected at append time
+ * with {@link validateTransition} or {@link appendRunEvent}.
+ */
+declare function deriveRunStatus(events: readonly RunEvent[]): RunStatus | "none";
+/**
+ * Validate and append one event: enforces schema strictness, monotonic `seq`,
+ * and the transition table. Shared by the hosted coordinator and the local
+ * client so both sides agree on what a legal Run history is.
+ */
+declare function appendRunEvent(events: readonly RunEvent[], candidate: RunEvent): RunEvent[];
+declare function isTerminalRunStatus(status: RunStatus): boolean;
+/**
+ * Merge local and hosted policy into the effective policy stamped on a Run.
+ * The hosted side can only narrow: ceilings combine by minimum, budgets by
+ * minimum, harness allowlists by intersection. The objective is a preference,
+ * so the local value wins when both are present. A hosted policy therefore can
+ * never raise a local permission ceiling — a tampered or malicious hosted
+ * response is inert.
+ */
+declare function mergePolicy(local: Partial<EffectivePolicy>, hosted?: Partial<EffectivePolicy>): EffectivePolicy;
+export { AGENT_ROUTER_SCHEMA_VERSION, AGENT_ROUTER_VERSION, type AgentFeedback, type AgentModel, type AgentRouteRequest, type AgentRouteResponse, type AgentTaskFeatures, type Allowance, type ApprovalKind, type ClientSurface, type EffectivePolicy, type ExecutionPlan, type FeaturizeAgentTaskInput, type HarnessId, type PermissionProfile, RUN_SCHEMA_VERSION, type Readiness, type RouteSelection, type RoutingObjective, type RunActor, type RunApproval, type RunCandidate, type RunDocument, type RunEvent, type RunEventType, type RunStatus, type TaskRole, agentFeedbackSchema, agentModelSchema, agentRouteRequestSchema, agentRouteResponseSchema, agentTaskFeaturesSchema, allowanceSchema, appendRunEvent, approvalKindSchema, approvalSurfaceSchema, clientSurfaceSchema, deriveRunStatus, effectivePolicySchema, executionPlanSchema, featurizeAgentTask, harnessIdSchema, isTerminalRunStatus, mergePolicy, permissionProfileSchema, readinessSchema, routingObjectiveSchema, runActorSchema, runApprovalSchema, runCandidateSchema, runDocumentSchema, runEventSchema, runStatusSchema, selectAgentRoute, taskRoleSchema, taskTypeSchema, validateTransition, workflowSchema };