toolroll 0.9.103 → 0.9.105

package/dist/contracts/gateway-tools.d.ts

@@ -1,472 +0,0 @@
-/**
- * The MCP gateway's tools (docs/plans/zod-revamp.md, item 5; docs/mcp-gateway-spec.md): one input schema per tool and
- * one output schema for what each returns. The input schema is the `inputSchema` tools/list advertises and the check
- * a call is read with before its handler runs (mcp.ts): a call it refuses is a JSON-RPC InvalidParams error naming each
- * path, never a tool refusal. The assignment tools' schemas are also what `toolroll assignment` reads its flags with
- * (assignment-adapters.ts), so the CLI and the gateway take exactly the same arguments.
- *
- * A coordinator names a project by its path and a task by `ref`; the lead's tools (lead-tools.ts) say r1 and `task`.
- * Output schemas describe a result's top level: checked in tests, logged when a result disagrees, never a refusal.
- */
-import { z } from "zod";
-/** The assignment tools, by the operation `toolroll assignment` names them. */
-export declare const ASSIGNMENT_INPUTS: {
-    readonly show: z.ZodObject<{
-        ref: z.ZodString;
-    }, z.core.$strict>;
-    readonly updates: z.ZodObject<{
-        after: z.ZodOptional<z.ZodInt>;
-        limit: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly claim: z.ZodObject<{
-        ref: z.ZodString;
-    }, z.core.$strict>;
-    readonly check: z.ZodObject<{
-        ref: z.ZodString;
-        digest: z.ZodString;
-    }, z.core.$strict>;
-    readonly brief: z.ZodObject<{
-        repo: z.ZodOptional<z.ZodString>;
-        limit: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly inbox: z.ZodObject<{
-        consumer: z.ZodString;
-        limit: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly ack: z.ZodObject<{
-        consumer: z.ZodString;
-        batchId: z.ZodString;
-    }, z.core.$strict>;
-};
-export type AssignmentOperation = keyof typeof ASSIGNMENT_INPUTS;
-export type AssignmentInput<O extends AssignmentOperation> = z.infer<(typeof ASSIGNMENT_INPUTS)[O]>;
-export declare const GATEWAY_TOOL_INPUTS: {
-    readonly get_project_context: z.ZodObject<{
-        repo: z.ZodString;
-        query: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            impact: "impact";
-            search: "search";
-        }>>;
-    }, z.core.$strict>;
-    readonly get_code_map: z.ZodObject<{
-        repo: z.ZodString;
-        version: z.ZodOptional<z.ZodInt>;
-        view: z.ZodEnum<{
-            area: "area";
-            file: "file";
-            overview: "overview";
-            search: "search";
-        }>;
-        id: z.ZodOptional<z.ZodString>;
-        query: z.ZodOptional<z.ZodString>;
-        cursor: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    readonly get_assignment: z.ZodObject<{
-        ref: z.ZodString;
-    }, z.core.$strict>;
-    readonly list_assignment_updates: z.ZodObject<{
-        after: z.ZodOptional<z.ZodInt>;
-        limit: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly claim_assignment: z.ZodObject<{
-        ref: z.ZodString;
-    }, z.core.$strict>;
-    readonly acknowledge_assignment: z.ZodObject<{
-        ref: z.ZodString;
-        digest: z.ZodString;
-    }, z.core.$strict>;
-    readonly get_assignment_brief: z.ZodObject<{
-        repo: z.ZodOptional<z.ZodString>;
-        limit: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly get_assignment_inbox: z.ZodObject<{
-        consumer: z.ZodString;
-        limit: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly acknowledge_assignment_delivery: z.ZodObject<{
-        consumer: z.ZodString;
-        batchId: z.ZodString;
-    }, z.core.$strict>;
-    readonly status: z.ZodObject<{}, z.core.$strict>;
-    readonly list_tasks: z.ZodObject<{
-        state: z.ZodOptional<z.ZodEnum<{
-            cancelled: "cancelled";
-            done: "done";
-            failed: "failed";
-            queued: "queued";
-            running: "running";
-        }>>;
-        repo: z.ZodOptional<z.ZodString>;
-        cursor: z.ZodOptional<z.ZodInt>;
-        limit: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly get_task: z.ZodObject<{
-        ref: z.ZodString;
-    }, z.core.$strict>;
-    readonly list_repos: z.ZodObject<{}, z.core.$strict>;
-    readonly recap: z.ZodObject<{
-        since: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    readonly list_decisions: z.ZodObject<{}, z.core.$strict>;
-    readonly queue: z.ZodObject<{
-        repo: z.ZodString;
-    }, z.core.$strict>;
-    readonly get_decision: z.ZodObject<{
-        decision: z.ZodInt;
-    }, z.core.$strict>;
-    readonly propose_next: z.ZodObject<{
-        ref: z.ZodString;
-    }, z.core.$strict>;
-    readonly propose_reserve: z.ZodObject<{
-        ref: z.ZodString;
-        worker: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>;
-    readonly propose_hold: z.ZodObject<{
-        ref: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strict>;
-    readonly propose_unhold: z.ZodObject<{
-        ref: z.ZodString;
-    }, z.core.$strict>;
-    readonly propose_scope: z.ZodObject<{
-        ref: z.ZodString;
-        goal: z.ZodString;
-        not: z.ZodOptional<z.ZodString>;
-        touches: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
-    readonly propose_cancel: z.ZodObject<{
-        ref: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strict>;
-    readonly propose_answer: z.ZodObject<{
-        decision: z.ZodInt;
-        option: z.ZodString;
-        rationale: z.ZodString;
-    }, z.core.$strict>;
-    readonly get_contract: z.ZodObject<{}, z.core.$strict>;
-    readonly file_proposal: z.ZodObject<{
-        repo: z.ZodString;
-        title: z.ZodString;
-        intent: z.ZodOptional<z.ZodString>;
-        idempotency_key: z.ZodString;
-        deliverable: z.ZodOptional<z.ZodEnum<{
-            branch: "branch";
-            report: "report";
-        }>>;
-    }, z.core.$strict>;
-};
-export type GatewayToolName = keyof typeof GATEWAY_TOOL_INPUTS;
-export type GatewayToolInput<N extends GatewayToolName> = z.infer<(typeof GATEWAY_TOOL_INPUTS)[N]>;
-export declare const GATEWAY_TOOL_OUTPUTS: {
-    readonly get_project_context: z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        readOnly: z.ZodBoolean;
-        query: z.ZodString;
-        mode: z.ZodEnum<{
-            impact: "impact";
-            search: "search";
-        }>;
-        asOf: z.ZodString;
-        excerpts: z.ZodArray<z.ZodUnknown>;
-    }, z.core.$loose>;
-    readonly get_code_map: z.ZodObject<{
-        v: z.ZodLiteral<1>;
-        ok: z.ZodBoolean;
-    }, z.core.$loose>;
-    readonly get_assignment: z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        rootId: z.ZodString;
-        activeTaskId: z.ZodString;
-        title: z.ZodString;
-        state: z.ZodString;
-        detail: z.ZodString;
-        attention: z.ZodArray<z.ZodString>;
-    }, z.core.$loose>;
-    readonly list_assignment_updates: z.ZodObject<{
-        events: z.ZodArray<z.ZodUnknown>;
-        nextCursor: z.ZodNumber;
-        hasMore: z.ZodBoolean;
-    }, z.core.$loose>;
-    readonly claim_assignment: z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        rootId: z.ZodString;
-        activeTaskId: z.ZodString;
-        title: z.ZodString;
-        state: z.ZodString;
-        detail: z.ZodString;
-        attention: z.ZodArray<z.ZodString>;
-    }, z.core.$loose>;
-    readonly acknowledge_assignment: z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        rootId: z.ZodString;
-        activeTaskId: z.ZodString;
-        title: z.ZodString;
-        state: z.ZodString;
-        detail: z.ZodString;
-        attention: z.ZodArray<z.ZodString>;
-    }, z.core.$loose>;
-    readonly get_assignment_brief: z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        asOf: z.ZodString;
-        readOnly: z.ZodLiteral<true>;
-        assignments: z.ZodArray<z.ZodUnknown>;
-        projects: z.ZodArray<z.ZodUnknown>;
-        omissions: z.ZodObject<{}, z.core.$loose>;
-    }, z.core.$loose>;
-    readonly get_assignment_inbox: z.ZodObject<{
-        batch: z.ZodObject<{
-            id: z.ZodNullable<z.ZodString>;
-            consumer: z.ZodString;
-            events: z.ZodArray<z.ZodUnknown>;
-            hasMore: z.ZodBoolean;
-        }, z.core.$loose>;
-    }, z.core.$loose>;
-    readonly acknowledge_assignment_delivery: z.ZodObject<{
-        alreadyAcknowledged: z.ZodBoolean;
-    }, z.core.$loose>;
-    readonly status: z.ZodObject<{
-        waitsOnYou: z.ZodNumber;
-        waits: z.ZodObject<{
-            approvals: z.ZodNumber;
-            questions: z.ZodNumber;
-            incidents: z.ZodNumber;
-            picks: z.ZodNumber;
-        }, z.core.$loose>;
-    }, z.core.$loose>;
-    readonly list_tasks: z.ZodObject<{
-        tasks: z.ZodArray<z.ZodUnknown>;
-    }, z.core.$loose>;
-    readonly get_task: z.ZodObject<{
-        ref: z.ZodString;
-    }, z.core.$loose>;
-    readonly list_repos: z.ZodObject<{
-        repos: z.ZodArray<z.ZodObject<{
-            repo: z.ZodString;
-            mode: z.ZodString;
-        }, z.core.$loose>>;
-    }, z.core.$loose>;
-    readonly recap: z.ZodObject<{
-        since: z.ZodNullable<z.ZodString>;
-        repos: z.ZodArray<z.ZodUnknown>;
-        waitsOnYou: z.ZodObject<{
-            decisions: z.ZodArray<z.ZodUnknown>;
-            incidents: z.ZodNumber;
-            scopesAwaitingApproval: z.ZodArray<z.ZodUnknown>;
-        }, z.core.$loose>;
-        running: z.ZodArray<z.ZodUnknown>;
-        truncated: z.ZodBoolean;
-    }, z.core.$loose>;
-    readonly list_decisions: z.ZodObject<{
-        decisions: z.ZodArray<z.ZodObject<{
-            decision: z.ZodNumber;
-            task: z.ZodString;
-            question: z.ZodString;
-            options: z.ZodArray<z.ZodUnknown>;
-            ageHours: z.ZodNumber;
-        }, z.core.$loose>>;
-        truncated: z.ZodBoolean;
-    }, z.core.$loose>;
-    readonly queue: z.ZodObject<{
-        columns: z.ZodArray<z.ZodObject<{
-            column: z.ZodString;
-            tasks: z.ZodArray<z.ZodUnknown>;
-        }, z.core.$loose>>;
-        repo: z.ZodString;
-    }, z.core.$loose>;
-    readonly get_decision: z.ZodObject<{
-        repo: z.ZodString;
-        decision: z.ZodNumber;
-        task: z.ZodString;
-        state: z.ZodString;
-        question: z.ZodString;
-        options: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            label: z.ZodString;
-            reversible: z.ZodBoolean;
-            consequence: z.ZodString;
-        }, z.core.$loose>>;
-        ageHours: z.ZodNumber;
-    }, z.core.$loose>;
-    readonly propose_next: z.ZodObject<{
-        proposal: z.ZodNumber;
-        kind: z.ZodEnum<{
-            answer: "answer";
-            cancel: "cancel";
-            hold: "hold";
-            next: "next";
-            reserve: "reserve";
-            scope: "scope";
-            unhold: "unhold";
-        }>;
-        awaiting: z.ZodString;
-    }, z.core.$loose>;
-    readonly propose_reserve: z.ZodObject<{
-        proposal: z.ZodNumber;
-        kind: z.ZodEnum<{
-            answer: "answer";
-            cancel: "cancel";
-            hold: "hold";
-            next: "next";
-            reserve: "reserve";
-            scope: "scope";
-            unhold: "unhold";
-        }>;
-        awaiting: z.ZodString;
-    }, z.core.$loose>;
-    readonly propose_hold: z.ZodObject<{
-        proposal: z.ZodNumber;
-        kind: z.ZodEnum<{
-            answer: "answer";
-            cancel: "cancel";
-            hold: "hold";
-            next: "next";
-            reserve: "reserve";
-            scope: "scope";
-            unhold: "unhold";
-        }>;
-        awaiting: z.ZodString;
-    }, z.core.$loose>;
-    readonly propose_unhold: z.ZodObject<{
-        proposal: z.ZodNumber;
-        kind: z.ZodEnum<{
-            answer: "answer";
-            cancel: "cancel";
-            hold: "hold";
-            next: "next";
-            reserve: "reserve";
-            scope: "scope";
-            unhold: "unhold";
-        }>;
-        awaiting: z.ZodString;
-    }, z.core.$loose>;
-    readonly propose_scope: z.ZodObject<{
-        proposal: z.ZodNumber;
-        kind: z.ZodEnum<{
-            answer: "answer";
-            cancel: "cancel";
-            hold: "hold";
-            next: "next";
-            reserve: "reserve";
-            scope: "scope";
-            unhold: "unhold";
-        }>;
-        awaiting: z.ZodString;
-    }, z.core.$loose>;
-    readonly propose_cancel: z.ZodObject<{
-        proposal: z.ZodNumber;
-        kind: z.ZodEnum<{
-            answer: "answer";
-            cancel: "cancel";
-            hold: "hold";
-            next: "next";
-            reserve: "reserve";
-            scope: "scope";
-            unhold: "unhold";
-        }>;
-        awaiting: z.ZodString;
-    }, z.core.$loose>;
-    readonly propose_answer: z.ZodObject<{
-        proposal: z.ZodNumber;
-        kind: z.ZodEnum<{
-            answer: "answer";
-            cancel: "cancel";
-            hold: "hold";
-            next: "next";
-            reserve: "reserve";
-            scope: "scope";
-            unhold: "unhold";
-        }>;
-        awaiting: z.ZodString;
-    }, z.core.$loose>;
-    readonly get_contract: z.ZodObject<{
-        contract: z.ZodString;
-    }, z.core.$loose>;
-    readonly file_proposal: z.ZodObject<{
-        ref: z.ZodString;
-        replayed: z.ZodBoolean;
-        admission: z.ZodString;
-    }, z.core.$loose>;
-};
-export declare const PERSON_TOOL_INPUTS: {
-    readonly status: z.ZodObject<{}, z.core.$strict>;
-    readonly list_tasks: z.ZodObject<{
-        state: z.ZodOptional<z.ZodEnum<{
-            cancelled: "cancelled";
-            done: "done";
-            failed: "failed";
-            queued: "queued";
-            running: "running";
-        }>>;
-        repo: z.ZodOptional<z.ZodString>;
-        cursor: z.ZodOptional<z.ZodInt>;
-        limit: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly task_show: z.ZodObject<{
-        ref: z.ZodString;
-    }, z.core.$strict>;
-    readonly task_review: z.ZodObject<{
-        ref: z.ZodString;
-        run: z.ZodOptional<z.ZodInt>;
-        all: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>;
-    readonly review_findings: z.ZodObject<{
-        run: z.ZodInt;
-    }, z.core.$strict>;
-    readonly file_task: z.ZodObject<{
-        repo: z.ZodString;
-        title: z.ZodString;
-        idempotency_key: z.ZodString;
-        deliverable: z.ZodOptional<z.ZodEnum<{
-            branch: "branch";
-            report: "report";
-        }>>;
-    }, z.core.$strict>;
-};
-export type PersonToolName = keyof typeof PERSON_TOOL_INPUTS;
-export type PersonToolInput<N extends PersonToolName> = z.infer<(typeof PERSON_TOOL_INPUTS)[N]>;
-export declare const PERSON_TOOL_OUTPUTS: {
-    readonly status: z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodBoolean;
-        command: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>;
-    readonly list_tasks: z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodBoolean;
-        command: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>;
-    readonly task_show: z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodBoolean;
-        command: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>;
-    readonly task_review: z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodBoolean;
-        command: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>;
-    readonly review_findings: z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodBoolean;
-        command: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>;
-    readonly file_task: z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodBoolean;
-        command: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-        id: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>;
-};

package/dist/contracts/handoff.d.ts

@@ -1,91 +0,0 @@
-/**
- * The handoff artifact (`handoff.json`, M6.10): one schema for the machine's own statement of where a finished run
- * left the world — workspace identity, exact base and head, which answered decisions the brief carried, the agent's
- * conclusion and lists, and a freshness stamp a successor proves against the branch. `storeHandoffArtifact` writes it
- * and every reader reads it through `readHandoffArtifact`.
- *
- * The agent's own terminal handoff (`STANDING-ORDERS-DONE-*`, `parseHandoff` in decision.ts) is a different contract;
- * this file records what the machine made of it.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-export declare const ROUTE_PHASES: readonly ["plan", "build", "repair", "review"];
-export declare const ROUTE_CHOICES: readonly ["recommended", "override", "pinned", "legacy", "fallback"];
-/** The sealed route leg the run ran as (v47); absent on handoffs written before routes existed. */
-export declare const handoffRouteSchema: z.ZodObject<{
-    digest: z.ZodString;
-    phase: z.ZodEnum<{
-        build: "build";
-        plan: "plan";
-        repair: "repair";
-        review: "review";
-    }>;
-    provider: z.ZodString;
-    model: z.ZodNullable<z.ZodString>;
-    chosen: z.ZodEnum<{
-        fallback: "fallback";
-        legacy: "legacy";
-        override: "override";
-        pinned: "pinned";
-        recommended: "recommended";
-    }>;
-}, z.core.$strict>;
-export declare const HANDOFF_VERSION = 1;
-export declare const handoffSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    taskId: z.ZodString;
-    runId: z.ZodInt;
-    provider: z.ZodString;
-    model: z.ZodOptional<z.ZodString>;
-    route: z.ZodOptional<z.ZodObject<{
-        digest: z.ZodString;
-        phase: z.ZodEnum<{
-            build: "build";
-            plan: "plan";
-            repair: "repair";
-            review: "review";
-        }>;
-        provider: z.ZodString;
-        model: z.ZodNullable<z.ZodString>;
-        chosen: z.ZodEnum<{
-            fallback: "fallback";
-            legacy: "legacy";
-            override: "override";
-            pinned: "pinned";
-            recommended: "recommended";
-        }>;
-    }, z.core.$strict>>;
-    sessionId: z.ZodNullable<z.ZodString>;
-    branch: z.ZodString;
-    worktree: z.ZodString;
-    base: z.ZodString;
-    head: z.ZodString;
-    outcome: z.ZodEnum<{
-        built: "built";
-        "no-change": "no-change";
-    }>;
-    committed: z.ZodBoolean;
-    decisionsIncorporated: z.ZodArray<z.ZodInt>;
-    conclusion: z.ZodString;
-    changes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    verification: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    followUps: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    freshness: z.ZodObject<{
-        stampedAt: z.ZodString;
-        currentAsOf: z.ZodString;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type HandoffArtifact = z.infer<typeof handoffSchema>;
-/**
- * A handoff written before handoffs carried `version` (every handoff through 0.9.34, stamped `schema: 1`), as
- * version 1. The shape is the same; readers then read only the fields they knew and ignored any others, so this keeps
- * exactly the known fields. Anything not stamped `schema: 1` is left as it is, for the schema to refuse by path.
- */
-export declare function upgradeSchemaOneHandoff(body: Record<string, unknown>): Record<string, unknown>;
-export declare const HANDOFF_UPGRADES: {
-    readonly 0: typeof upgradeSchemaOneHandoff;
-};
-/** Read a handoff artifact: version 1 as itself, a `schema: 1` one upgraded, a newer one refused plainly. */
-export declare function readHandoffArtifact(input: unknown): ContractResult<HandoffArtifact>;
-/** Read a stored handoff's bytes: JSON first, then the schema. */
-export declare function parseHandoffArtifact(raw: string): ContractResult<HandoffArtifact>;

package/dist/contracts/health.d.ts

@@ -1,82 +0,0 @@
-import { z } from 'zod';
-export declare const latencySummarySchema: z.ZodObject<{
-    count: z.ZodNumber;
-    p50Ms: z.ZodNullable<z.ZodNumber>;
-    p99Ms: z.ZodNullable<z.ZodNumber>;
-    maxMs: z.ZodNullable<z.ZodNumber>;
-    totalMs: z.ZodNumber;
-}, z.core.$loose>;
-export declare const healthSnapshotSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    windowSeconds: z.ZodLiteral<300>;
-    uptimeSeconds: z.ZodNumber;
-    requests: z.ZodObject<{
-        count: z.ZodNumber;
-        p50Ms: z.ZodNullable<z.ZodNumber>;
-        p99Ms: z.ZodNullable<z.ZodNumber>;
-        maxMs: z.ZodNullable<z.ZodNumber>;
-        totalMs: z.ZodNumber;
-    }, z.core.$loose>;
-    routes: z.ZodRecord<z.ZodEnum<{
-        assets: "assets";
-        auth: "auth";
-        chat: "chat";
-        cli: "cli";
-        console: "console";
-        decisions: "decisions";
-        flows: "flows";
-        health: "health";
-        live: "live";
-        mcp: "mcp";
-        metrics: "metrics";
-        other: "other";
-        projects: "projects";
-        results: "results";
-        sessions: "sessions";
-        settings: "settings";
-        tasks: "tasks";
-        team: "team";
-    }> & z.core.$partial, z.ZodObject<{
-        count: z.ZodNumber;
-        p50Ms: z.ZodNullable<z.ZodNumber>;
-        p99Ms: z.ZodNullable<z.ZodNumber>;
-        maxMs: z.ZodNullable<z.ZodNumber>;
-        totalMs: z.ZodNumber;
-    }, z.core.$loose>>;
-    eventLoop: z.ZodObject<{
-        count: z.ZodNumber;
-        p50Ms: z.ZodNullable<z.ZodNumber>;
-        p99Ms: z.ZodNullable<z.ZodNumber>;
-        maxMs: z.ZodNullable<z.ZodNumber>;
-        totalMs: z.ZodNumber;
-    }, z.core.$loose>;
-    writes: z.ZodObject<{
-        wait: z.ZodObject<{
-            count: z.ZodNumber;
-            p50Ms: z.ZodNullable<z.ZodNumber>;
-            p99Ms: z.ZodNullable<z.ZodNumber>;
-            maxMs: z.ZodNullable<z.ZodNumber>;
-            totalMs: z.ZodNumber;
-        }, z.core.$loose>;
-        hold: z.ZodObject<{
-            count: z.ZodNumber;
-            p50Ms: z.ZodNullable<z.ZodNumber>;
-            p99Ms: z.ZodNullable<z.ZodNumber>;
-            maxMs: z.ZodNullable<z.ZodNumber>;
-            totalMs: z.ZodNumber;
-        }, z.core.$loose>;
-        statement: z.ZodObject<{
-            count: z.ZodNumber;
-            p50Ms: z.ZodNullable<z.ZodNumber>;
-            p99Ms: z.ZodNullable<z.ZodNumber>;
-            maxMs: z.ZodNullable<z.ZodNumber>;
-            totalMs: z.ZodNumber;
-        }, z.core.$loose>;
-    }, z.core.$loose>;
-    streams: z.ZodObject<{
-        open: z.ZodNumber;
-        queuedBytes: z.ZodNumber;
-        maxQueuedBytes: z.ZodNumber;
-    }, z.core.$loose>;
-    budgetRefusals: z.ZodNumber;
-}, z.core.$loose>;