@minionry/sdk 0.4.23

package/dist/types.d.ts

@@ -0,0 +1,1967 @@
+export declare const SCOPES: readonly ["identity", "storage", "files:app", "pm:read", "agents:run", "pm:write", "files:workspace:read", "files:workspace:write", "notifications", "pm:execute", "pm:schedule", "agents:sessions", "browser:read", "browser:control", "settings:read", "git:read", "git:write", "git:remote", "terminal:read", "terminal:exec", "tools:serve", "quality:read", "quality:run", "inference:run", "endpoints:register"];
+export type Scope = (typeof SCOPES)[number];
+export type ScopeRiskTier = 'low' | 'medium' | 'high' | 'critical';
+export declare const SCOPE_RISK_TIERS: Readonly<Record<Scope, ScopeRiskTier>>;
+export declare const MINIONRY_ERROR_CODES: readonly ["USER_REJECTED", "SCOPE_DENIED", "RATE_LIMITED", "SPACE_DISCONNECTED", "QUOTA_EXCEEDED", "UNSUPPORTED", "CANCELLED"];
+export type MinionryErrorCode = (typeof MINIONRY_ERROR_CODES)[number];
+export declare class MinionryError extends Error {
+    readonly code: MinionryErrorCode | (string & {});
+    constructor(code: MinionryErrorCode | (string & {}), message?: string);
+}
+export type Unsubscribe = () => void;
+export interface ConnectRequest {
+    scopes: Scope[];
+}
+export interface SpaceInfo {
+    id: string;
+    name: string;
+}
+export interface UserInfo {
+    id: string;
+    name: string;
+    role: string;
+}
+export interface ConnectResult {
+    space: SpaceInfo;
+    user: UserInfo | null;
+    grants: Scope[];
+    viewOnly: boolean;
+}
+export declare const AGENT_RUN_LIMITS: {
+    readonly maxSystemPromptChars: 32000;
+    readonly maxTurns: 50;
+    readonly maxSeconds: 1800;
+    readonly endpointsPerApp: 8;
+    readonly maxTtlMs: 86400000;
+};
+export declare const AGENT_RUN_MODEL_SELECTIONS: readonly ["quality"];
+export type AgentRunModelSelection = (typeof AGENT_RUN_MODEL_SELECTIONS)[number];
+export interface AgentRunRequest {
+    prompt: string;
+    title?: string;
+    model?: string;
+    modelSelection?: AgentRunModelSelection;
+    systemPrompt?: string;
+    budget?: {
+        maxTurns?: number;
+        maxSeconds?: number;
+    };
+    sessionId?: string;
+}
+export type AgentRunResultStatus = 'done' | 'error' | 'cancelled';
+export type AgentRunStatus = 'running' | AgentRunResultStatus;
+export interface AgentRunResult {
+    status: AgentRunResultStatus;
+    text: string;
+}
+export interface AgentRunEventMap {
+    output: {
+        text: string;
+    };
+    toolUse: {
+        tool: string;
+        input?: unknown;
+    };
+    status: {
+        status: AgentRunStatus;
+    };
+    gap: {
+        message: string;
+    };
+    timelineEvent: SessionEvent;
+}
+export type AgentRunEvent = keyof AgentRunEventMap;
+export interface AgentRun {
+    readonly id: string;
+    readonly sessionId: string;
+    on<E extends AgentRunEvent>(event: E, cb: (payload: AgentRunEventMap[E]) => void): Unsubscribe;
+    result(): Promise<AgentRunResult>;
+    cancel(): Promise<void>;
+}
+export interface SessionSummary {
+    id: string;
+    name: string;
+    createdAt: string;
+    lastActivityAt: string;
+    isExecuting: boolean;
+    leaseState?: 'active' | 'parked' | 'released';
+}
+export interface CreateSessionRequest {
+    name?: string;
+}
+export interface RenameSessionRequest {
+    name: string;
+}
+export type SessionEntry = {
+    id: string;
+    kind: 'user';
+    at: number;
+    engine?: string;
+    text: string;
+    attachments?: Array<{
+        fileName: string;
+        isImage: boolean;
+    }>;
+    turn?: number;
+} | {
+    id: string;
+    kind: 'text';
+    at: number;
+    engine?: string;
+    text: string;
+    open: boolean;
+} | {
+    id: string;
+    kind: 'thinking';
+    at: number;
+    engine?: string;
+    text: string;
+    open: boolean;
+} | {
+    id: string;
+    kind: 'tool';
+    at: number;
+    engine?: string;
+    toolName: string;
+    toolUseId?: string;
+    input: Record<string, unknown>;
+    status: 'running' | 'success' | 'error';
+    result?: string;
+    completedAt?: number;
+} | {
+    id: string;
+    kind: 'notice';
+    at: number;
+    engine?: string;
+    level: 'info' | 'warning' | 'error';
+    text: string;
+    code?: string;
+    data?: Record<string, unknown>;
+} | {
+    id: string;
+    kind: 'question';
+    at: number;
+    engine?: string;
+    toolUseId: string;
+    questions: readonly unknown[];
+    state: 'pending' | 'answered' | 'auto-answered' | 'dismissed';
+};
+export type SessionEvent = {
+    kind: 'user';
+    at: number;
+    engine?: string;
+    entryId: string;
+    text: string;
+    attachments?: Array<{
+        fileName: string;
+        isImage: boolean;
+    }>;
+    turn?: number;
+} | {
+    kind: 'text';
+    at: number;
+    engine?: string;
+    entryId: string;
+    delta: string;
+} | {
+    kind: 'thinking';
+    at: number;
+    engine?: string;
+    entryId: string;
+    delta: string;
+} | {
+    kind: 'tool_use';
+    at: number;
+    engine?: string;
+    entryId: string;
+    toolName: string;
+    toolUseId?: string;
+    input: Record<string, unknown>;
+} | {
+    kind: 'tool_result';
+    at: number;
+    engine?: string;
+    entryId: string;
+    ok: boolean;
+    result: string;
+} | {
+    kind: 'notice';
+    at: number;
+    engine?: string;
+    entryId: string;
+    level: 'info' | 'warning' | 'error';
+    text: string;
+    code?: string;
+    data?: Record<string, unknown>;
+} | {
+    kind: 'question';
+    at: number;
+    engine?: string;
+    entryId: string;
+    toolUseId: string;
+    questions: readonly unknown[];
+} | {
+    kind: 'question_state';
+    at: number;
+    engine?: string;
+    entryId: string;
+    state: 'pending' | 'answered' | 'auto-answered' | 'dismissed';
+} | {
+    kind: 'tokens';
+    at: number;
+    engine?: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationTokens: number;
+        cacheReadTokens: number;
+        currentTurnInputTokens: number;
+        isFinal?: boolean;
+    };
+} | {
+    kind: 'status';
+    at: number;
+    engine?: string;
+    executing: boolean;
+    startedAt?: number;
+    turn?: number;
+} | {
+    kind: 'truncate';
+    at: number;
+    engine?: string;
+    throughEntryId: string;
+};
+export interface SessionHistory {
+    sessionId: string;
+    entries: SessionEntry[];
+    seq: number;
+}
+export interface SessionReplayResult {
+    sessionId: string;
+    fromSeq: number;
+    events: SessionEvent[];
+    currentSeq: number;
+}
+export interface SessionPromptResult {
+    queued: boolean;
+}
+export interface PromptAttachmentRef {
+    path: string;
+}
+export interface MinionryAgentSessions {
+    list(): Promise<SessionSummary[]>;
+    create(req?: CreateSessionRequest): Promise<SessionSummary>;
+    attach(sessionId: string): Promise<SessionSummary>;
+    close(sessionId: string): Promise<void>;
+    rename(sessionId: string, req: RenameSessionRequest): Promise<SessionSummary>;
+    history(sessionId: string): Promise<SessionHistory>;
+    replay(sessionId: string, afterSeq: number): Promise<SessionReplayResult>;
+    approve(sessionId: string, approved: boolean): Promise<void>;
+    answerQuestion(sessionId: string, toolUseId: string, answers: Record<string, string>): Promise<void>;
+    prompt(sessionId: string, text: string, attachments?: PromptAttachmentRef[]): Promise<SessionPromptResult>;
+    stop(sessionId: string): Promise<void>;
+}
+export interface BoardRunInput {
+    variables?: Record<string, string | number | boolean>;
+    data?: unknown;
+    gatherPrompt?: string;
+}
+export interface CreateBoardRequest {
+    prompt: string;
+    autoImplement?: boolean;
+    input?: BoardRunInput;
+}
+export interface CreateBoardResult {
+    boardId: string;
+}
+export interface BoardSummary {
+    id: string;
+    title: string;
+    status: 'draft' | 'active' | 'completed' | 'archived';
+    goal: string;
+    created: string;
+    completedAt: string | null;
+}
+export interface BoardIssue {
+    id: string;
+    title: string;
+    status: string;
+    type?: string;
+    priority?: string;
+    labels?: string[];
+}
+export interface BoardSnapshot {
+    boardId: string;
+    title: string;
+    statuses: string[];
+    issues: BoardIssue[];
+}
+export interface BoardIssueDetail {
+    id: string;
+    title: string;
+    type: 'issue' | 'epic' | 'bug' | 'task';
+    status: string;
+    priority: string;
+    estimate: number | string | null;
+    labels: string[];
+    epicId: string | null;
+    blockedBy: string[];
+    blocks: string[];
+    description: string;
+    acceptanceCriteria: Array<{
+        text: string;
+        checked: boolean;
+    }>;
+    created: string;
+    updated: string | null;
+}
+export interface UpdateIssueFields {
+    title?: string;
+    status?: string;
+    priority?: 'P0' | 'P1' | 'P2' | 'P3';
+    estimate?: number | string | null;
+    labels?: string[];
+    epicId?: string | null;
+    blockedBy?: string[];
+    blocks?: string[];
+}
+export interface CreateIssueRequest extends UpdateIssueFields {
+    boardId: string;
+    title: string;
+    type?: 'issue' | 'epic' | 'bug' | 'task';
+    description?: string;
+    acceptanceCriteria?: string[];
+}
+export interface UpdateBoardFields {
+    title?: string;
+    status?: 'draft' | 'active' | 'completed';
+    goal?: string;
+    maxParallelAgents?: number;
+    autoImplement?: boolean;
+}
+export interface BoardRunEventMap {
+    issueStarted: {
+        issueId: string;
+        title: string;
+    };
+    output: {
+        issueId: string;
+        text: string;
+    };
+    tokens: {
+        issueId: string;
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationTokens: number;
+        cacheReadTokens: number;
+        currentTurnInputTokens: number;
+        isFinal: boolean;
+    };
+    toolUse: {
+        issueId: string;
+        tool: string;
+        input?: unknown;
+    };
+    reviewProgress: {
+        issueId: string;
+        status: string;
+    };
+    issueComplete: {
+        issueId: string;
+    };
+    complete: {
+        reason: string;
+    };
+    gap: {
+        message: string;
+    };
+}
+export type BoardRunEvent = keyof BoardRunEventMap;
+export interface BoardRun {
+    readonly id: string;
+    readonly boardId: string;
+    on<E extends BoardRunEvent>(event: E, cb: (payload: BoardRunEventMap[E]) => void): Unsubscribe;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    stop(): Promise<void>;
+}
+export type ScheduleTiming = 
+{
+    kind: 'once';
+    at: string;
+}
+ | {
+    kind: 'interval';
+    everyMs: number;
+}
+ | {
+    kind: 'continuous';
+};
+export type ScheduleFireStatus = 'started' | 'completed' | 'failed' | 'skipped-overlap' | 'missed';
+export interface ScheduleHistoryEntry {
+    at: string;
+    status: ScheduleFireStatus;
+    boardId: string | null;
+    error?: string;
+}
+export interface ScheduleSource {
+    kind: 'template-json' | 'board-zip';
+    originalName?: string;
+}
+export interface ScheduleSnapshot {
+    id: string;
+    createdAt: string;
+    name?: string;
+    source: ScheduleSource;
+    input?: BoardRunInput;
+    timing: ScheduleTiming;
+    enabled: boolean;
+    nextFireAt: string | null;
+    lastFire?: {
+        at: string;
+        boardId: string | null;
+        status: ScheduleFireStatus;
+    };
+    history: ScheduleHistoryEntry[];
+}
+export interface CreateScheduleRequest {
+    name?: string;
+    source: {
+        kind: 'template-json';
+        content: string;
+    };
+    timing: ScheduleTiming;
+    input?: BoardRunInput;
+    enabled?: boolean;
+}
+export interface UpdateScheduleRequest {
+    name?: string;
+    timing?: ScheduleTiming;
+    input?: BoardRunInput | null;
+    enabled?: boolean;
+}
+export interface MinionryPmSchedules {
+    list(): Promise<ScheduleSnapshot[]>;
+    create(req: CreateScheduleRequest): Promise<ScheduleSnapshot>;
+    update(scheduleId: string, patch: UpdateScheduleRequest): Promise<ScheduleSnapshot>;
+    delete(scheduleId: string): Promise<void>;
+}
+export interface FileEntry {
+    name: string;
+    dir: boolean;
+    kind: 'file' | 'directory';
+    size?: number;
+    modifiedAt?: string;
+}
+export type FileReadResult = {
+    kind: 'text';
+    content: string;
+} | {
+    kind: 'binary';
+    content: string;
+    mimeType: string;
+};
+export interface FileSearchOptions {
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+    regex?: boolean;
+    contextLines?: number;
+    includeGlob?: string;
+    excludeGlob?: string;
+    maxResults?: number;
+}
+export interface FileSearchMatch {
+    path: string;
+    line: number;
+    column: number;
+    lineContent: string;
+    contextBefore: string[];
+    contextAfter: string[];
+}
+export interface FileSearchCompleteResult {
+    totalMatches: number;
+    fileCount: number;
+    truncated: boolean;
+    error?: string;
+}
+export interface FileSearchEventMap {
+    results: {
+        matches: FileSearchMatch[];
+    };
+    complete: FileSearchCompleteResult;
+    gap: {
+        message: string;
+    };
+}
+export type FileSearchEvent = keyof FileSearchEventMap;
+export interface FileSearchHandle {
+    readonly id: string;
+    on<E extends FileSearchEvent>(event: E, cb: (payload: FileSearchEventMap[E]) => void): Unsubscribe;
+    cancel(): Promise<void>;
+}
+export interface FileDefinitionOptions {
+    language?: string;
+    currentFile?: string;
+}
+export interface FileDefinition {
+    path: string;
+    line: number;
+    column: number;
+    lineContent: string;
+    kind: string;
+}
+export interface FileChangeEvent {
+    path: string;
+    kind: 'changed' | 'opened';
+}
+export interface FileTransferProgress {
+    chunkIndex: number;
+    totalChunks: number;
+    bytesTransferred: number;
+    totalBytes: number;
+}
+export interface FileTransferEventMap {
+    progress: FileTransferProgress;
+}
+export type FileTransferEvent = keyof FileTransferEventMap;
+export interface FileUploadOptions {
+    mimeType?: string;
+    overwrite?: boolean;
+}
+export interface FileUploadResult {
+    path: string;
+    bytesWritten: number;
+}
+export interface FileDownloadOptions {
+    asZip?: boolean;
+}
+export interface FileDownloadResult {
+    path: string;
+    bytes: Uint8Array;
+    mimeType: string;
+    isZip: boolean;
+    fileSize: number;
+}
+export interface FileTransferHandle<TResult> {
+    readonly id: string;
+    on<E extends FileTransferEvent>(event: E, cb: (payload: FileTransferEventMap[E]) => void): Unsubscribe;
+    result(): Promise<TResult>;
+    cancel(): Promise<void>;
+}
+export interface BrowserDeviceProfile {
+    formFactor: 'desktop' | 'mobile';
+    width: number;
+    height: number;
+    label: string;
+}
+export interface BrowserTab {
+    id: string;
+    url: string;
+    title: string;
+    favicon?: string;
+    isLoading: boolean;
+    canGoBack: boolean;
+    canGoForward: boolean;
+    error?: string;
+    deviceProfile?: BrowserDeviceProfile;
+    owner?: {
+        agentId: string;
+        label: string;
+        sessionId?: string;
+    };
+}
+export interface BrowserTabsPayload {
+    tabs: BrowserTab[];
+    currentTabId: string | null;
+}
+export interface BrowserOpenOptions {
+    pinnedApp?: boolean;
+}
+export interface BrowserSnapshotNode {
+    ref: string;
+    role: string;
+    name?: string;
+    value?: string;
+    description?: string;
+    level?: number;
+    checked?: boolean | 'mixed';
+    selected?: boolean;
+    expanded?: boolean;
+    disabled?: boolean;
+    focused?: boolean;
+    children: BrowserSnapshotNode[];
+}
+export interface BrowserSnapshotResult {
+    url: string;
+    title: string;
+    epoch: number;
+    root: BrowserSnapshotNode;
+}
+export interface BrowserScreenshotOptions {
+    fullPage?: boolean;
+    format?: 'png' | 'jpeg';
+    quality?: number;
+}
+export interface BrowserScreenshotResult {
+    format: 'png' | 'jpeg';
+    data: string;
+}
+export interface BrowserEvaluateOptions {
+    world?: 'main' | 'isolated';
+    timeoutMs?: number;
+}
+export interface BrowserEvaluateResult {
+    value: unknown;
+    type: string;
+    error?: string;
+}
+export interface BrowserPreflightCheck {
+    id: string;
+    label: string;
+    reason?: string | null;
+    fixCommands: string[];
+    advisory?: boolean;
+}
+export interface BrowserPreflightResult {
+    ok: boolean;
+    platform?: string;
+    packageManager?: string | null;
+    chromiumInstalling?: boolean;
+    missing?: BrowserPreflightCheck[];
+    message?: string;
+}
+export type BrowserAutomateEngine = 'claude-code' | 'codex' | 'hermes';
+export interface BrowserAutomateOptions {
+    engine?: BrowserAutomateEngine;
+    model?: string;
+    tabId?: string;
+}
+export type BrowserAutomationPhase = 'observe' | 'act' | 'extract' | 'plan';
+export type BrowserAutomationStatus = 'success' | 'error' | 'cancelled';
+export type BrowserAutomationVerdict = 'approve' | 'edit' | 'deny';
+export interface BrowserAutomationEventMap {
+    proposed: {
+        proposalId: string;
+        summary: string;
+    };
+    step: {
+        phase: BrowserAutomationPhase;
+        detail: string;
+        proposalId?: string;
+        engine?: BrowserAutomateEngine;
+        model?: string;
+        sessionId?: string;
+    };
+    done: {
+        status: BrowserAutomationStatus;
+        result?: string;
+        error?: string;
+    };
+    session: {
+        sessionId: string;
+        name: string;
+    };
+    gap: {
+        message: string;
+    };
+}
+export type BrowserAutomationEvent = keyof BrowserAutomationEventMap;
+export interface BrowserAutomation {
+    readonly id: string;
+    on<E extends BrowserAutomationEvent>(event: E, cb: (payload: BrowserAutomationEventMap[E]) => void): Unsubscribe;
+    approve(proposalId: string, verdict?: BrowserAutomationVerdict, editedText?: string): Promise<void>;
+    cancel(): Promise<void>;
+}
+export interface BrowserIceCandidateInit {
+    candidate?: string;
+    sdpMLineIndex?: number | null;
+    sdpMid?: string | null;
+    usernameFragment?: string | null;
+}
+export interface BrowserIceServer {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+}
+export type BrowserViewConnectionState = 'negotiating' | 'connected' | 'failed' | 'closed';
+export interface BrowserViewAttachOptions {
+    tabId?: string;
+    bounds?: BrowserViewBounds;
+}
+export interface BrowserViewBounds {
+    width: number;
+    height: number;
+    x?: number;
+    y?: number;
+    mobile?: boolean;
+    deviceScaleFactor?: number;
+}
+export declare const BROWSER_INPUT_MODIFIERS: {
+    readonly alt: 1;
+    readonly ctrl: 2;
+    readonly meta: 4;
+    readonly shift: 8;
+};
+export type BrowserMouseButton = 'none' | 'left' | 'middle' | 'right' | 'back' | 'forward';
+export interface BrowserTouchPoint {
+    x: number;
+    y: number;
+    id: number;
+    force?: number;
+    radiusX?: number;
+    radiusY?: number;
+}
+export interface BrowserMouseInput {
+    kind: 'mouse';
+    eventType: 'mousePressed' | 'mouseReleased' | 'mouseMoved' | 'mouseWheel';
+    x: number;
+    y: number;
+    button: BrowserMouseButton;
+    buttons: number;
+    clickCount: number;
+    modifiers: number;
+    deltaX?: number;
+    deltaY?: number;
+    deltaMode?: number;
+    sourceWidth?: number;
+    sourceHeight?: number;
+}
+export interface BrowserKeyInput {
+    kind: 'key';
+    eventType: 'keyDown' | 'rawKeyDown' | 'keyUp';
+    key: string;
+    code: string;
+    keyCode?: number;
+    text?: string;
+    modifiers: number;
+    isComposing?: boolean;
+}
+export interface BrowserTouchInput {
+    kind: 'touch';
+    eventType: 'touchStart' | 'touchMove' | 'touchEnd' | 'touchCancel';
+    touchPoints: BrowserTouchPoint[];
+    modifiers: number;
+    sourceWidth?: number;
+    sourceHeight?: number;
+}
+export interface BrowserTextInput {
+    kind: 'text';
+    text: string;
+}
+export interface BrowserImeInput {
+    kind: 'ime';
+    eventType: 'start' | 'update' | 'commit';
+    imeText?: string;
+    text?: string;
+    selectionStart?: number;
+    selectionEnd?: number;
+}
+export type BrowserInputEnvelope = BrowserMouseInput | BrowserKeyInput | BrowserTouchInput | BrowserTextInput | BrowserImeInput;
+export type BrowserInputRejectReason = 'no_active_view' | 'unsupported_kind' | 'modifier_only_key' | 'host_not_ready' | 'malformed' | 'unknown';
+export interface BrowserDriverStateSnapshot {
+    tabId: string;
+    state: 'idle' | 'automation' | 'human' | 'closed';
+    mode?: 'driving' | 'parked';
+    pendingResume?: boolean;
+    parkedReason?: string;
+    since: number;
+    lastInputAt?: number;
+    lastInputActor?: 'user' | 'agent';
+    ownerAgentId?: string;
+    ownerAgentLabel?: string;
+}
+export interface BrowserViewEventMap {
+    offer: {
+        sdp: string;
+        iceServers?: BrowserIceServer[];
+    };
+    ice: {
+        candidate: BrowserIceCandidateInit | null;
+    };
+    connectionState: {
+        state: BrowserViewConnectionState;
+        reason?: string;
+    };
+    navigationState: {
+        tabId: string;
+        url: string;
+        title: string;
+        isLoading: boolean;
+        canGoBack: boolean;
+        canGoForward: boolean;
+    };
+    driverState: BrowserDriverStateSnapshot;
+    inputFocus: {
+        focused: boolean;
+    };
+    inputRejected: {
+        kind: string;
+        reason: BrowserInputRejectReason;
+        message?: string;
+    };
+    gap: {
+        message: string;
+    };
+}
+export type BrowserViewEvent = keyof BrowserViewEventMap;
+export interface BrowserInputResult {
+    delivered: boolean;
+    reason?: BrowserInputRejectReason;
+}
+export interface BrowserViewSession {
+    readonly id: string;
+    readonly tabId: string;
+    on<E extends BrowserViewEvent>(event: E, cb: (payload: BrowserViewEventMap[E]) => void): Unsubscribe;
+    answer(sdp: string): Promise<void>;
+    addIceCandidate(candidate: BrowserIceCandidateInit | null): Promise<void>;
+    setConnectionState(state: BrowserViewConnectionState, reason?: string): Promise<void>;
+    sendInput(input: BrowserInputEnvelope | BrowserInputEnvelope[]): Promise<BrowserInputResult>;
+    setBounds(bounds: BrowserViewBounds): Promise<void>;
+    detach(): Promise<void>;
+}
+export interface MinionryBrowserView {
+    attach(opts?: BrowserViewAttachOptions): Promise<BrowserViewSession>;
+}
+export interface MinionryBrowserTabs {
+    list(): Promise<BrowserTabsPayload>;
+    onChanged(cb: (payload: BrowserTabsPayload) => void): Unsubscribe;
+}
+export type BrowserErrorCode = 'BROWSER_NOT_PROVISIONED' | 'BROWSER_HOST_FAILED';
+export interface MinionryBrowser {
+    readonly tabs: MinionryBrowserTabs;
+    readonly view: MinionryBrowserView;
+    navigate(url: string, tabId?: string): Promise<void>;
+    back(tabId?: string): Promise<void>;
+    forward(tabId?: string): Promise<void>;
+    reload(tabId?: string): Promise<void>;
+    stop(tabId?: string): Promise<void>;
+    open(url: string, opts?: BrowserOpenOptions): Promise<{
+        tabId: string;
+    }>;
+    close(tabId: string): Promise<void>;
+    select(tabId: string): Promise<void>;
+    snapshot(tabId: string): Promise<BrowserSnapshotResult>;
+    screenshot(tabId: string, opts?: BrowserScreenshotOptions): Promise<BrowserScreenshotResult>;
+    evaluate(tabId: string, expr: string, opts?: BrowserEvaluateOptions): Promise<BrowserEvaluateResult>;
+    automate(prompt: string, opts?: BrowserAutomateOptions): Promise<BrowserAutomation>;
+    preflight(): Promise<BrowserPreflightResult>;
+    resumeDriver(tabId: string): Promise<void>;
+    setDeviceProfile(tabId: string, formFactor: 'desktop' | 'mobile'): Promise<void>;
+}
+export interface OpenAppRequest {
+    app: string;
+    params?: Record<string, unknown>;
+}
+export type AppsOpenBrowserParams = {
+    tabId: string;
+};
+export type BrowserIntentParams = {
+    tabId: string;
+};
+export interface MinionryAuth {
+    getToken(): Promise<string>;
+}
+export interface MinionryAgents {
+    run(req: AgentRunRequest): Promise<AgentRun>;
+    readonly sessions: MinionryAgentSessions;
+}
+export interface MinionryPm {
+    createBoard(req: CreateBoardRequest): Promise<CreateBoardResult>;
+    getBoard(boardId: string): Promise<BoardSnapshot>;
+    listBoards(): Promise<BoardSummary[]>;
+    onBoardUpdate(boardId: string, cb: (snapshot: BoardSnapshot) => void): Unsubscribe;
+    createIssue(req: CreateIssueRequest): Promise<BoardIssueDetail>;
+    updateIssue(boardId: string, issueId: string, fields: UpdateIssueFields): Promise<BoardIssueDetail>;
+    deleteIssue(boardId: string, issueId: string): Promise<void>;
+    updateBoard(boardId: string, fields: UpdateBoardFields): Promise<BoardSummary>;
+    execute(boardId: string): Promise<BoardRun>;
+    readonly schedules: MinionryPmSchedules;
+}
+export interface MinionryFiles {
+    read(path: string): Promise<string>;
+    readEntry(path: string): Promise<FileReadResult>;
+    write(path: string, content: string): Promise<void>;
+    list(path: string): Promise<FileEntry[]>;
+    delete(path: string): Promise<void>;
+    mkdir(path: string): Promise<void>;
+    rename(path: string, newPath: string): Promise<void>;
+    search(path: string, query: string, options?: FileSearchOptions): Promise<FileSearchHandle>;
+    definition(path: string, symbolName: string, opts?: FileDefinitionOptions): Promise<FileDefinition[]>;
+    onChanged(path: string, cb: (change: FileChangeEvent) => void): Unsubscribe;
+    upload(path: string, data: Uint8Array, opts?: FileUploadOptions): Promise<FileTransferHandle<FileUploadResult>>;
+    download(path: string, opts?: FileDownloadOptions): Promise<FileTransferHandle<FileDownloadResult>>;
+}
+export interface MinionryApps {
+    open(req: OpenAppRequest): Promise<void>;
+}
+export interface MinionryStorage {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+}
+export interface NotificationStatus {
+    granted: boolean;
+}
+export interface MinionryNotifications {
+    request(): Promise<void>;
+    status(): Promise<NotificationStatus>;
+    revoke(): Promise<void>;
+}
+export type ThemeMode = 'light' | 'dark';
+export interface ThemeSnapshot {
+    mode: ThemeMode;
+    tokens: Record<string, string>;
+}
+export interface MinionryTheme {
+    get(): Promise<ThemeSnapshot>;
+}
+export interface LocaleSnapshot {
+    locale: string;
+    dir: 'ltr' | 'rtl';
+}
+export interface MinionryLocale {
+    get(): Promise<LocaleSnapshot>;
+}
+export interface AutocompleteEntry {
+    value: string;
+    label: string;
+    isDirectory: boolean;
+    isRecent: boolean;
+    fileType: string;
+    matchedIndices: Array<[number, number]>;
+}
+export interface SkillCatalogEntry {
+    name: string;
+    displayName: string;
+    description: string;
+    source: 'project' | 'user' | 'system' | 'builtin' | 'platform';
+}
+export interface SnippetCatalogEntry {
+    name: string;
+    aliases: readonly string[];
+    description: string;
+    origin: 'project' | 'personal';
+    preview: string;
+    bodyLength: number;
+}
+export interface ComposerModelEntry {
+    value: string;
+    engine: string;
+    label?: string;
+    description?: string;
+    isDefault?: boolean;
+    contextLength?: number;
+}
+export interface ComposerModelCatalogStatus {
+    fetchedAt: string | null;
+    stale: boolean;
+    refreshing: boolean;
+}
+export interface ComposerSettingsCatalog {
+    engines: string[];
+    defaults: {
+        engine: string;
+        model: string;
+        effortLevel: string;
+        fastMode: boolean;
+    };
+    models?: ComposerModelEntry[];
+    modelsStatus?: ComposerModelCatalogStatus;
+    effortLevels?: Record<string, string[]>;
+    inferenceEngines?: string[];
+}
+export interface MinionryComposer {
+    autocomplete(query: string): Promise<AutocompleteEntry[]>;
+    skills(): Promise<SkillCatalogEntry[]>;
+    snippets(query?: string): Promise<SnippetCatalogEntry[]>;
+    settings(): Promise<ComposerSettingsCatalog>;
+}
+export interface GitWorktreeSelector {
+    worktree?: string;
+}
+export interface GitFileStatus {
+    path: string;
+    status: 'M' | 'A' | 'D' | '?' | 'R' | 'C' | 'U';
+    staged: boolean;
+    originalPath?: string;
+}
+export interface GitCommitSuggestion {
+    workingDir: string;
+    branch: string;
+    message: string;
+    generatedAt: number;
+}
+export interface GitStatusResult {
+    branch: string;
+    isDirty: boolean;
+    staged: GitFileStatus[];
+    unstaged: GitFileStatus[];
+    untracked: GitFileStatus[];
+    ahead: number;
+    behind: number;
+    hasUpstream: boolean;
+    commitSuggestion?: GitCommitSuggestion;
+}
+export interface GitLogRequest extends GitWorktreeSelector {
+    limit?: number;
+    skip?: number;
+    search?: string;
+}
+export interface GitLogEntry {
+    hash: string;
+    shortHash: string;
+    subject: string;
+    author: string;
+    date: string;
+}
+export interface GitLogResult {
+    entries: GitLogEntry[];
+    hasMore?: boolean;
+    skip?: number;
+    search?: string;
+}
+export interface GitDiffRequest extends GitWorktreeSelector {
+    path: string;
+    staged?: boolean;
+}
+export interface GitDiffResult {
+    path: string;
+    original: string;
+    modified: string;
+    staged: boolean;
+}
+export interface GitCommitFile {
+    path: string;
+    status: string;
+    additions: number;
+    deletions: number;
+    oldPath?: string;
+}
+export interface GitCommitDetail {
+    hash: string;
+    shortHash: string;
+    subject: string;
+    body: string;
+    author: string;
+    date: string;
+    files: GitCommitFile[];
+}
+export interface GitCommitDiffRequest extends GitWorktreeSelector {
+    hash: string;
+    path: string;
+}
+export interface GitCommitDiffResult {
+    hash: string;
+    path: string;
+    original: string;
+    modified: string;
+}
+export interface GitBranchEntry {
+    name: string;
+    shortHash: string;
+    isRemote: boolean;
+    isCurrent: boolean;
+    upstream?: string;
+    lastCommitDate?: string;
+    ahead?: number;
+    behind?: number;
+    upstreamGone?: boolean;
+}
+export interface GitBranchListResult {
+    branches: GitBranchEntry[];
+    current: string;
+}
+export interface GitCreateBranchRequest extends GitWorktreeSelector {
+    name: string;
+    startPoint?: string;
+    checkout?: boolean;
+}
+export interface GitBranchCreateResult {
+    name: string;
+    hash: string;
+}
+export interface GitDeleteBranchRequest extends GitWorktreeSelector {
+    name: string;
+    force?: boolean;
+}
+export interface MinionryGitBranches {
+    list(req?: GitWorktreeSelector): Promise<GitBranchListResult>;
+    create(req: GitCreateBranchRequest): Promise<GitBranchCreateResult>;
+    delete(req: GitDeleteBranchRequest): Promise<void>;
+}
+export interface GitTagEntry {
+    name: string;
+    shortHash: string;
+    date: string;
+    message: string;
+}
+export interface GitTagListResult {
+    tags: GitTagEntry[];
+}
+export interface GitCreateTagRequest extends GitWorktreeSelector {
+    name: string;
+    message?: string;
+    commit?: string;
+}
+export interface GitTagCreateResult {
+    name: string;
+    hash: string;
+}
+export interface GitPushTagRequest extends GitWorktreeSelector {
+    name?: string;
+    all?: boolean;
+}
+export interface GitTagPushResult {
+    name: string;
+    output: string;
+}
+export interface MinionryGitTags {
+    list(req?: GitWorktreeSelector): Promise<GitTagListResult>;
+    create(req: GitCreateTagRequest): Promise<GitTagCreateResult>;
+    push(req?: GitPushTagRequest): Promise<GitTagPushResult>;
+}
+export interface GitRemoteInfo {
+    hasRemote: boolean;
+    remoteUrl?: string;
+    provider?: 'github' | 'gitlab' | 'unknown';
+    defaultBranch?: string;
+    currentBranch?: string;
+    hasGhCli?: boolean;
+    ghCliAuthenticated?: boolean;
+    ghCliBinary?: 'gh' | 'glab';
+    remoteBranches?: string[];
+    preferredBaseBranch?: string;
+}
+export interface MinionryGitRemote {
+    info(req?: GitWorktreeSelector): Promise<GitRemoteInfo>;
+}
+export interface GitRepoInfo {
+    path: string;
+    name: string;
+    branch?: string;
+}
+export interface GitReposDiscoverResult {
+    repos: GitRepoInfo[];
+    rootIsGitRepo: boolean;
+}
+export interface MinionryGitRepos {
+    discover(): Promise<GitReposDiscoverResult>;
+}
+export interface GitWorktreeStatusSummary {
+    staged: number;
+    unstaged: number;
+    untracked: number;
+    ahead: number;
+    behind: number;
+    hasUpstream: boolean;
+}
+export interface GitWorktreeInfo {
+    path: string;
+    branch?: string;
+    head: string;
+    isMain: boolean;
+    isBare: boolean;
+    prunable?: boolean;
+    status?: GitWorktreeStatusSummary;
+}
+export interface GitWorktreesListResult {
+    worktrees: GitWorktreeInfo[];
+    activeWorktreePath: string | null;
+}
+export interface GitWorktreeCreateRequest {
+    branchName: string;
+    baseBranch?: string;
+    path?: string;
+    assign?: boolean;
+}
+export interface GitWorktreeCreateResult {
+    path: string;
+    branch: string;
+    head: string;
+}
+export interface GitWorktreeRemoveRequest {
+    path: string;
+    force?: boolean;
+    deleteBranch?: boolean;
+}
+export interface GitWorktreeSwitchActiveRequest {
+    path?: string | null;
+}
+export interface GitWorktreeSwitchActiveResult {
+    path: string | null;
+    branch: string | null;
+}
+export interface MinionryGitWorktrees {
+    list(): Promise<GitWorktreesListResult>;
+    create(req: GitWorktreeCreateRequest): Promise<GitWorktreeCreateResult>;
+    remove(req: GitWorktreeRemoveRequest): Promise<void>;
+    switchActive(req?: GitWorktreeSwitchActiveRequest): Promise<GitWorktreeSwitchActiveResult>;
+    onChanged(cb: (payload: GitWorktreesListResult) => void): Unsubscribe;
+}
+export interface GitMergeBlocker {
+    path: string;
+    status: 'M' | 'A' | 'D' | '?' | 'R' | 'C' | 'U';
+    staged: boolean;
+}
+export interface GitMergePreviewRequest extends GitWorktreeSelector {
+    sourceBranch: string;
+    targetBranch: string;
+}
+export interface GitMergePreviewResult {
+    clean: boolean;
+    conflicts: string[];
+    stat: string;
+    commits: Array<{
+        hash: string;
+        message: string;
+    }>;
+    ahead: number;
+    targetWorktreePath?: string;
+    targetWorktreeBlockers?: GitMergeBlocker[];
+}
+export interface GitMergeRunRequest extends GitWorktreeSelector {
+    sourceBranch: string;
+    targetBranch: string;
+    strategy: 'merge' | 'squash' | 'rebase';
+    commitMessage?: string;
+    deleteWorktree?: boolean;
+    deleteBranch?: boolean;
+    stashFirst?: boolean;
+}
+export interface GitMergeRunResult {
+    success: boolean;
+    mergeCommit?: string;
+    error?: string;
+    conflictFiles?: string[];
+    warnings?: string[];
+    targetWorktreePath?: string;
+    targetWorktreeBlockers?: GitMergeBlocker[];
+    stashRef?: string;
+    stashSha?: string;
+    stashMessage?: string;
+}
+export interface GitMergeAbortResult {
+    aborted: boolean;
+}
+export interface GitMergeCompleteResult {
+    success: boolean;
+    mergeCommit: string;
+}
+export interface GitMergeStashPopRequest extends GitWorktreeSelector {
+    stashSha: string;
+}
+export interface GitMergeStashPopResult {
+    success: boolean;
+    error?: string;
+    targetWorktreePath?: string;
+}
+export interface GitMergeDiscardBlockersRequest extends GitWorktreeSelector {
+    paths: string[];
+}
+export interface GitMergeDiscardBlockersResult {
+    success: boolean;
+    error?: string;
+    targetWorktreePath?: string;
+    paths?: string[];
+}
+export interface MinionryGitMerge {
+    preview(req: GitMergePreviewRequest): Promise<GitMergePreviewResult>;
+    run(req: GitMergeRunRequest): Promise<GitMergeRunResult>;
+    abort(req?: GitWorktreeSelector): Promise<GitMergeAbortResult>;
+    complete(req?: GitWorktreeSelector): Promise<GitMergeCompleteResult>;
+    stashPop(req: GitMergeStashPopRequest): Promise<GitMergeStashPopResult>;
+    discardBlockers(req: GitMergeDiscardBlockersRequest): Promise<GitMergeDiscardBlockersResult>;
+}
+export interface GitPrDescriptionRequest extends GitWorktreeSelector {
+    baseBranch?: string;
+}
+export interface GitPrDescriptionResult {
+    title: string;
+    body: string;
+}
+export interface GitCreatePrRequest extends GitWorktreeSelector {
+    title: string;
+    body?: string;
+    baseBranch?: string;
+    draft?: boolean;
+}
+export interface GitCreatePrResult {
+    url: string;
+    method?: 'gh' | 'glab' | 'browser';
+    prNumber?: number;
+}
+export interface MinionryGitPr {
+    generateDescription(req?: GitPrDescriptionRequest): Promise<GitPrDescriptionResult>;
+    create(req: GitCreatePrRequest): Promise<GitCreatePrResult>;
+}
+export interface GitStageRequest extends GitWorktreeSelector {
+    paths?: string[];
+    stageAll?: boolean;
+}
+export interface GitStageResult {
+    paths: string[];
+}
+export interface GitUnstageRequest extends GitWorktreeSelector {
+    paths: string[];
+}
+export interface GitCommitRequest extends GitWorktreeSelector {
+    message: string;
+}
+export interface GitCommitResult {
+    hash: string;
+    message: string;
+}
+export interface GitGenerateCommitMessageResult {
+    message: string;
+}
+export interface GitCheckoutRequest extends GitWorktreeSelector {
+    branch: string;
+    create?: boolean;
+    startPoint?: string;
+}
+export interface GitCheckoutResult {
+    branch: string;
+    previous: string;
+}
+export interface GitPushRequest extends GitWorktreeSelector {
+    remote?: string;
+    branch?: string;
+    setUpstream?: boolean;
+}
+export interface GitPushResult {
+    output: string;
+    upstream?: string;
+}
+export interface GitPullResult {
+    output: string;
+}
+export interface GitBranchChangedEvent {
+    worktreePath: string;
+    branch: string;
+}
+export interface MinionryGit {
+    status(req?: GitWorktreeSelector): Promise<GitStatusResult>;
+    log(req?: GitLogRequest): Promise<GitLogResult>;
+    diff(req: GitDiffRequest): Promise<GitDiffResult>;
+    show(hash: string, req?: GitWorktreeSelector): Promise<GitCommitDetail>;
+    commitDiff(req: GitCommitDiffRequest): Promise<GitCommitDiffResult>;
+    readonly branches: MinionryGitBranches;
+    readonly tags: MinionryGitTags;
+    readonly remote: MinionryGitRemote;
+    readonly repos: MinionryGitRepos;
+    readonly worktrees: MinionryGitWorktrees;
+    readonly merge: MinionryGitMerge;
+    readonly pr: MinionryGitPr;
+    stage(req: GitStageRequest): Promise<GitStageResult>;
+    unstage(req: GitUnstageRequest): Promise<GitStageResult>;
+    commit(req: GitCommitRequest): Promise<GitCommitResult>;
+    generateCommitMessage(req?: GitWorktreeSelector): Promise<GitGenerateCommitMessageResult>;
+    checkout(req: GitCheckoutRequest): Promise<GitCheckoutResult>;
+    push(req?: GitPushRequest): Promise<GitPushResult>;
+    pull(req?: GitWorktreeSelector): Promise<GitPullResult>;
+    onBranchChanged(cb: (payload: GitBranchChangedEvent) => void): Unsubscribe;
+    onCommitSuggestion(cb: (payload: GitCommitSuggestion) => void): Unsubscribe;
+}
+export interface TerminalSessionSummary {
+    id: string;
+    shell: string;
+    cwd: string;
+    cols: number;
+    rows: number;
+    createdAt: string;
+    lastActivityAt: string;
+    ownerLabel?: string;
+}
+export type TerminalSessionChangeEvent = {
+    kind: 'opened';
+    session: TerminalSessionSummary;
+} | {
+    kind: 'closed';
+    id: string;
+};
+export interface MinionryTerminalSessions {
+    list(): Promise<TerminalSessionSummary[]>;
+    onChanged(cb: (change: TerminalSessionChangeEvent) => void): Unsubscribe;
+}
+export interface TerminalOpenOptions {
+    cwd?: string;
+    cols: number;
+    rows: number;
+}
+export interface TerminalOpenResult {
+    id: string;
+    shell: string;
+    cwd: string;
+    cols: number;
+    rows: number;
+    platform: string;
+}
+export interface TerminalSize {
+    cols: number;
+    rows: number;
+}
+export interface TerminalEventMap {
+    output: {
+        data: string;
+    };
+    exit: {
+        exitCode: number;
+    };
+    error: {
+        message: string;
+    };
+    scrollback: {
+        data: string;
+    };
+    gap: {
+        message: string;
+    };
+}
+export type TerminalEvent = keyof TerminalEventMap;
+export interface TerminalHandle {
+    readonly id: string;
+    on<E extends TerminalEvent>(event: E, cb: (payload: TerminalEventMap[E]) => void): Unsubscribe;
+    detach(): Promise<void>;
+}
+export type TerminalErrorCode = 'PTY_NOT_AVAILABLE';
+export interface MinionryTerminal {
+    readonly sessions: MinionryTerminalSessions;
+    open(opts: TerminalOpenOptions): Promise<TerminalOpenResult>;
+    attach(id: string): Promise<TerminalHandle>;
+    write(id: string, data: string | string[]): Promise<void>;
+    resize(id: string, size: TerminalSize): Promise<void>;
+    close(id: string): Promise<void>;
+}
+export type AppToolProfile = 'browser';
+export interface AppToolSpec {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    timeoutMs?: number;
+}
+export interface AppToolDefinition extends AppToolSpec {
+    handler(input: unknown, ctx: AppToolCallContext): unknown | Promise<unknown>;
+}
+export interface AppToolCallContext {
+    readonly callId: string;
+    readonly tool: string;
+    readonly signal: AbortSignal;
+}
+export interface RegisterToolsRequest {
+    tools: AppToolDefinition[];
+    profile?: AppToolProfile;
+}
+export interface ToolsRegistration {
+    readonly id: string;
+    readonly tools: readonly string[];
+    unregister(): Promise<void>;
+}
+export interface MinionryTools {
+    register(req: RegisterToolsRequest): Promise<ToolsRegistration>;
+}
+export type AppToolsErrorCode = 'APP_UNAVAILABLE' | 'APP_TIMEOUT' | 'APP_ERROR';
+export type QualityGrade = 'A+' | 'A' | 'A-' | 'B+' | 'B' | 'B-' | 'C+' | 'C' | 'C-' | 'D' | 'F+' | 'F' | 'F-' | 'N/A';
+export type QualityDimensionName = 'security' | 'reliability' | 'maintainability';
+export type QualitySeverity = 'critical' | 'high' | 'medium' | 'low';
+export type QualityFindingStatus = 'confirmed' | 'uncertain' | 'likely-fp';
+export interface QualityFindingDismissal {
+    reason: string;
+    dismissedAt: string;
+}
+export interface QualityFinding {
+    severity: QualitySeverity;
+    category: string;
+    file: string;
+    line: number | null;
+    title: string;
+    description: string;
+    suggestion?: string;
+    evidence?: string;
+    verified?: boolean;
+    verificationNote?: string;
+    status?: QualityFindingStatus;
+    confidence?: number;
+    triageRationale?: string;
+    fingerprint?: string;
+    introduced?: boolean;
+    dismissal?: QualityFindingDismissal;
+}
+export interface QualityDimension {
+    name: QualityDimensionName;
+    score: number | null;
+    grade: QualityGrade;
+    rationale: string;
+    available: boolean;
+    findingCount: number;
+    worstSeverity: QualitySeverity | null;
+}
+export type QualityReadinessLevel = 'insufficient-data' | 'blocked' | 'testing' | 'develop' | 'production';
+export interface QualityReadiness {
+    level: QualityReadinessLevel;
+    headline: string;
+    rationale: string;
+    blockers: string[];
+}
+export interface QualityGateResult {
+    passed: boolean;
+    failingConditions: string[];
+}
+export interface QualityTriageSummary {
+    total: number;
+    confirmed: number;
+    likelyFalsePositive: number;
+    uncertain: number;
+}
+export interface QualityCategoryScore {
+    name: string;
+    score: number;
+    available: boolean;
+    issueCount?: number;
+    reason?: string;
+}
+export interface QualityCategoryPenalty {
+    category: string;
+    score: number;
+    grade: string;
+    penalty: number;
+    findingCount: number;
+}
+export interface QualityScoreBreakdown {
+    penaltyDensity: number;
+    totalPenalty: number;
+    issueDensity: number;
+    kloc: number;
+    categoryPenalties: QualityCategoryPenalty[];
+}
+export interface QualityReport {
+    path: string;
+    overall: number | null;
+    grade: QualityGrade;
+    dimensions: QualityDimension[];
+    categories: QualityCategoryScore[];
+    findings: QualityFinding[];
+    codeReview: QualityFinding[];
+    analyzedFiles: number;
+    totalLines: number;
+    timestamp: string;
+    ecosystem: string[];
+    scoreBreakdown?: QualityScoreBreakdown;
+    gate?: QualityGateResult;
+    gradeRationale?: string;
+    readiness?: QualityReadiness;
+    triage?: QualityTriageSummary;
+    scanDurationMs?: number;
+    reviewDurationMs?: number;
+    reviewSessionId?: string;
+    baselineAt?: string;
+    agentCost?: QualityAgentCost;
+    structuralScope?: QualityStructuralScope;
+    changeActivity?: QualityChangeActivity;
+    commit?: QualityCommitRef;
+}
+export interface QualityStructuralScope {
+    files: number;
+    extensions: string[];
+}
+export interface QualityCommitRef {
+    sha: string;
+    branch: string;
+    dirty: boolean;
+}
+export interface QualityChangeActivityFile {
+    commits: number;
+    linesChanged: number;
+    lastChangedAt: string;
+}
+export interface QualityChangeActivity {
+    available: boolean;
+    reason?: string;
+    windowDays: number;
+    commitsScanned: number;
+    truncated: boolean;
+    files: Record<string, QualityChangeActivityFile>;
+}
+export type QualityAgentCost = 
+{
+    available: false;
+    reason: string;
+} | {
+    available: true;
+    sampledAt: string;
+    sampledTurns: number;
+    truncated: boolean;
+    attributedTurns: number;
+    unattributed: {
+        missingOutputTokens: number;
+        outsideSpaceRoot: number;
+        unknownWriteTools: number;
+    };
+    unreadableFiles: number;
+    files: QualityAgentCostFile[];
+    comparison: QualityAgentCostComparison;
+};
+export interface QualityAgentCostFile {
+    file: string;
+    turns: number;
+    medianOutputTokens?: number;
+    medianDurationMs?: number;
+    reason?: string;
+}
+export interface QualityAgentCostSide {
+    turns: number;
+    medianOutputTokens?: number;
+    reason?: string;
+}
+export interface QualityAgentCostComparison {
+    withStructuralFindings: QualityAgentCostSide;
+    withoutStructuralFindings: QualityAgentCostSide;
+}
+export interface QualityDirectory {
+    path: string;
+    label: string;
+}
+export interface QualityHistoryEntry {
+    timestamp: string;
+    overall: number | null;
+    grade: QualityGrade;
+    issueDensity?: number;
+    categoryScores?: Array<{
+        category: string;
+        score: number;
+        grade: string;
+    }>;
+    dimensionScores?: Record<QualityDimensionName, {
+        score: number | null;
+        grade: QualityGrade;
+    }>;
+    directories: Array<{
+        path: string;
+        score: number | null;
+        grade: QualityGrade;
+    }>;
+    scanDurationMs?: number;
+    reviewDurationMs?: number;
+    commit?: QualityCommitRef;
+}
+export type QualityOperationKind = 'scanning' | 'reviewing' | 'fixing';
+export interface QualityActiveOperation {
+    kind: QualityOperationKind;
+    path: string;
+    startedAt: string;
+    sessionId?: string;
+}
+export type QualityPendingResult = {
+    kind: 'scanResults';
+    path: string;
+    completedAt: string;
+    report: QualityReport;
+} | {
+    kind: 'codeReview';
+    path: string;
+    completedAt: string;
+    findings: QualityFinding[];
+};
+export interface QualityState {
+    directories: QualityDirectory[];
+    reports: Record<string, QualityReport>;
+    history: QualityHistoryEntry[];
+    activeOperations: QualityActiveOperation[];
+    pendingResults: QualityPendingResult[];
+    schedules?: QualityScheduleSnapshot[];
+}
+export type QualityScheduleTiming = 
+{
+    kind: 'daily';
+    time: string;
+    timeZone: string;
+    days?: number[];
+}
+ | {
+    kind: 'interval';
+    everyMs: number;
+};
+export interface QualityScheduleHistoryEntry {
+    at: string;
+    status: ScheduleFireStatus;
+    error?: string;
+}
+export interface QualityScheduleSnapshot {
+    id: string;
+    createdAt: string;
+    name?: string;
+    path: string;
+    timing: QualityScheduleTiming;
+    enabled: boolean;
+    nextFireAt: string | null;
+    lastFire?: {
+        at: string;
+        status: ScheduleFireStatus;
+    };
+    history: QualityScheduleHistoryEntry[];
+}
+export interface CreateQualityScheduleRequest {
+    path?: string;
+    name?: string;
+    timing: QualityScheduleTiming;
+    enabled?: boolean;
+}
+export interface UpdateQualityScheduleRequest {
+    name?: string;
+    timing?: QualityScheduleTiming;
+    enabled?: boolean;
+}
+export interface MinionryQualitySchedules {
+    list(): Promise<QualityScheduleSnapshot[]>;
+    create(req: CreateQualityScheduleRequest): Promise<QualityScheduleSnapshot>;
+    update(scheduleId: string, patch: UpdateQualityScheduleRequest): Promise<QualityScheduleSnapshot>;
+    delete(scheduleId: string): Promise<void>;
+}
+export interface QualityTool {
+    name: string;
+    installed: boolean;
+    installCommand: string;
+    category: 'linter' | 'formatter' | 'complexity' | 'general' | 'security';
+}
+export interface QualityToolsResult {
+    path: string;
+    tools: QualityTool[];
+    ecosystem: string[];
+}
+export interface QualitySettings {
+    engine: string;
+    model: string;
+    effortLevel: string;
+    fastMode: boolean;
+    agentNotes?: boolean;
+}
+export interface QualitySettingsUpdate {
+    engine?: string;
+    model?: string;
+    effortLevel?: string;
+    fastMode?: boolean;
+    agentNotes?: boolean;
+}
+export type QualityChangeEvent = 
+{
+    kind: 'results';
+    path: string;
+    report: QualityReport;
+}
+ | {
+    kind: 'directories';
+    directories: QualityDirectory[];
+}
+ | {
+    kind: 'tools';
+    path: string;
+    tools: QualityTool[];
+    ecosystem: string[];
+}
+ | {
+    kind: 'postSession';
+    path: string;
+    report: QualityReport;
+}
+ | {
+    kind: 'agentTurn';
+    path: string;
+    worktree?: true;
+    changedFiles: string[];
+    report: QualityReport;
+}
+ | {
+    kind: 'schedules';
+    schedules: QualityScheduleSnapshot[];
+};
+export type QualityRunPhase = 'detecting' | 'installing' | 'scanning' | 'reviewing' | 'complete';
+export interface QualityRunProgress {
+    phase: QualityRunPhase;
+    step: string;
+    current: number;
+    total: number;
+    detail?: string;
+    etaMs?: number;
+    startedAt?: number;
+    sessionId?: string;
+}
+export interface QualityRunEventMap {
+    progress: QualityRunProgress;
+    phase: {
+        phase: QualityRunPhase;
+        sessionId?: string;
+    };
+    session: {
+        sessionId: string;
+    };
+}
+export type QualityRunEvent = keyof QualityRunEventMap;
+export type QualityLegStatus = 'ok' | 'skipped' | 'failed';
+export interface QualityLegOutcome {
+    status: QualityLegStatus;
+    code?: string;
+    message?: string;
+    sessionId?: string;
+}
+export type QualityRunStatus = 'ok' | 'partial' | 'error' | 'cancelled';
+export interface QualityRunResult {
+    path: string;
+    status: QualityRunStatus;
+    report: QualityReport | null;
+    legs: {
+        scan: QualityLegOutcome;
+        review: QualityLegOutcome;
+    };
+    sessionId?: string;
+}
+export interface QualityRun {
+    readonly path: string;
+    readonly attached: boolean;
+    on<E extends QualityRunEvent>(event: E, cb: (payload: QualityRunEventMap[E]) => void): Unsubscribe;
+    result(): Promise<QualityRunResult>;
+}
+export type QualityErrorCode = 'CLAUDE_NOT_INSTALLED' | 'OPERATION_IN_PROGRESS';
+export type QualityFindingState = 'dismissed' | 'active';
+export interface QualityFindingStateRequest {
+    path: string;
+    fingerprints: string[];
+    state: QualityFindingState;
+    reason?: string;
+}
+export interface QualityFindingStateResult {
+    applied: number;
+    dropped: number;
+}
+export interface MinionryQuality {
+    state(): Promise<QualityState>;
+    detectTools(path?: string): Promise<QualityToolsResult>;
+    run(path?: string): Promise<QualityRun>;
+    cancel(path?: string): Promise<void>;
+    installTools(path?: string, tools?: string[]): Promise<QualityToolsResult>;
+    saveDirectories(directories: QualityDirectory[]): Promise<void>;
+    settings(): Promise<QualitySettings>;
+    setSettings(settings: QualitySettingsUpdate): Promise<QualitySettings>;
+    onChanged(cb: (change: QualityChangeEvent) => void): Unsubscribe;
+    setFindingState(request: QualityFindingStateRequest): Promise<QualityFindingStateResult>;
+    readonly schedules: MinionryQualitySchedules;
+}
+export interface InferenceMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
+export interface InferenceChatRequest {
+    messages: InferenceMessage[];
+    system?: string;
+    engine?: string;
+    model?: string;
+    effortLevel?: string;
+}
+export type InferenceRunResultStatus = 'done' | 'error' | 'cancelled';
+export type InferenceRunStatus = 'running' | InferenceRunResultStatus;
+export interface InferenceUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+export type InferenceErrorCode = 'ENGINE_UNAVAILABLE' | 'ENGINE_AUTH' | 'ENGINE_LIMIT' | 'TIMEOUT' | 'UPSTREAM_ERROR';
+export interface InferenceRunResult {
+    status: InferenceRunResultStatus;
+    text: string;
+    engine: string;
+    model?: string;
+    usage?: InferenceUsage;
+    error?: {
+        code: InferenceErrorCode | (string & {});
+        message: string;
+    };
+}
+export interface InferenceRunEventMap {
+    delta: {
+        text: string;
+    };
+    usage: InferenceUsage;
+    status: {
+        status: InferenceRunStatus;
+    };
+    gap: {
+        message: string;
+    };
+}
+export type InferenceRunEvent = keyof InferenceRunEventMap;
+export interface InferenceRun {
+    readonly id: string;
+    on<E extends InferenceRunEvent>(event: E, cb: (payload: InferenceRunEventMap[E]) => void): Unsubscribe;
+    result(): Promise<InferenceRunResult>;
+    cancel(): Promise<void>;
+}
+export interface MinionryInference {
+    chat(req: InferenceChatRequest): Promise<InferenceRun>;
+}
+export type AppEndpointErrorCode = 'ENDPOINT_INVALID' | 'MODEL_NOT_ALLOWED' | 'ENGINE_UNAVAILABLE';
+export interface RegisterEndpointRequest {
+    id: string;
+    label: string;
+    engine: 'hermes';
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    contextLength?: number;
+    ttlMs?: number;
+}
+export interface RegisteredEndpoint {
+    id: string;
+    label: string;
+    engine: 'hermes';
+    modelValue: string;
+    model: string;
+    contextLength?: number;
+    expiresAt: string;
+}
+export interface MinionryEndpoints {
+    register(req: RegisterEndpointRequest): Promise<RegisteredEndpoint>;
+    unregister(id: string): Promise<void>;
+    list(): Promise<RegisteredEndpoint[]>;
+}
+export interface ProviderEventMap {
+    disconnect: void;
+    grantsChanged: Scope[];
+    spaceChanged: SpaceInfo;
+    fileChangeGap: {
+        path: string;
+        message: string;
+    };
+    themeChanged: ThemeSnapshot;
+    localeChanged: LocaleSnapshot;
+    boardGap: {
+        boardId: string;
+        message: string;
+    };
+    intent: {
+        source: string;
+        params?: Record<string, unknown>;
+    };
+}
+export type ProviderEvent = keyof ProviderEventMap;
+export interface MinionryProvider {
+    readonly version: '1';
+    features(): Promise<string[]>;
+    connect(req: ConnectRequest): Promise<ConnectResult>;
+    disconnect(): Promise<void>;
+    readonly auth: MinionryAuth;
+    readonly agents: MinionryAgents;
+    readonly apps: MinionryApps;
+    readonly pm: MinionryPm;
+    readonly files: MinionryFiles;
+    readonly storage: MinionryStorage;
+    readonly notifications: MinionryNotifications;
+    readonly theme: MinionryTheme;
+    readonly locale: MinionryLocale;
+    readonly browser: MinionryBrowser;
+    readonly composer: MinionryComposer;
+    readonly terminal: MinionryTerminal;
+    readonly git: MinionryGit;
+    readonly tools: MinionryTools;
+    readonly quality: MinionryQuality;
+    readonly inference: MinionryInference;
+    readonly endpoints: MinionryEndpoints;
+    on<E extends ProviderEvent>(event: E, cb: (payload: ProviderEventMap[E]) => void): Unsubscribe;
+}