qlogicagent 2.13.3 → 2.13.5

package/dist/protocol/wire/notification-payloads.d.ts

@@ -0,0 +1,918 @@
+/**
+ * Agent Notification Payload Types — wire-format contract for all JSON-RPC notifications.
+ *
+ * These types define the exact shape of `params` in every notification the agent emits.
+ * Consumers (openclaw UI, Hub relay, Electron, test harness) import from here
+ * to get type-safe access to event payloads without depending on agent internals.
+ *
+ * Design: Agent's protocol/notifications.ts re-exports these; adding a new event =
+ * 1. Add payload interface here
+ * 2. Add entry in NotificationMethodMap here
+ * 3. Add event name string in agent-events.ts (if WS-relayed)
+ */
+import type { ToolRiskLevel } from "./web-capability.js";
+/** Identifies which agent produced this notification (main or teammate). */
+export interface AgentSource {
+    id: string;
+    name: string;
+    role: "main" | "teammate";
+}
+/** Token usage as sent on the wire (JSON-RPC notifications). */
+export interface WireTokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+}
+/** Embedded thread item for clients using the Thread protocol. */
+export interface NotificationThreadItem {
+    id: string;
+    type: string;
+    role: "user" | "assistant" | "system";
+    text?: string;
+    toolName?: string;
+    toolCallId?: string;
+    arguments?: string;
+    output?: string;
+    approved?: boolean;
+    strategy?: string;
+    createdAt: string;
+}
+export type MediaResultType = "image" | "tts" | "video" | "music" | "3d";
+export type ArtifactType = "code" | "file" | "image" | "document" | "diagram" | "table";
+/** Turn started — always emitted first. */
+export interface TurnStartNotification {
+    turnId: string;
+    model?: string;
+    provider?: string;
+    /** Project that owns this session — enables frontend to associate without fallback guessing */
+    projectId?: string;
+}
+/** Streaming text chunk from the main agent. */
+export interface TurnDeltaNotification {
+    turnId: string;
+    text: string;
+    item?: NotificationThreadItem;
+    agentSource?: AgentSource;
+}
+/** Turn completed successfully. */
+export interface TurnEndNotification {
+    turnId: string;
+    content: string;
+    usage?: WireTokenUsage;
+    model?: string;
+    provider?: string;
+    item?: NotificationThreadItem;
+    agentSource?: AgentSource;
+}
+/** Turn failed. */
+export interface TurnErrorNotification {
+    turnId: string;
+    error: {
+        message: string;
+        code?: string;
+    };
+}
+/** Agent self-recovered from an error. */
+export interface TurnRecoveryNotification {
+    turnId: string;
+    action: string;
+    detail?: string;
+    item?: NotificationThreadItem;
+}
+/** Tool invocation started. */
+export interface TurnToolCallNotification {
+    turnId: string;
+    callId: string;
+    name: string;
+    arguments?: string;
+    inputSummary?: string;
+    item?: NotificationThreadItem;
+    agentSource?: AgentSource;
+}
+/** Tool execution completed. */
+export interface TurnToolResultNotification {
+    turnId: string;
+    callId: string;
+    name: string;
+    ok: boolean;
+    error?: string;
+    outputPreview?: string;
+    durationMs?: number;
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    details?: Record<string, unknown>;
+    item?: NotificationThreadItem;
+}
+/** Tool execution blocked by permission system. */
+export interface TurnToolBlockedNotification {
+    turnId: string;
+    callId: string;
+    name: string;
+    reason: string;
+    item?: NotificationThreadItem;
+}
+/** Reasoning/thinking token stream. */
+export interface TurnReasoningDeltaNotification {
+    turnId: string;
+    delta?: string;
+    /** Alias for delta — used by stdio-server event forwarding. */
+    text?: string;
+}
+/** Plan/strategy update. */
+export interface TurnPlanUpdateNotification {
+    turnId: string;
+    slug: string;
+    content: string;
+    item?: NotificationThreadItem;
+}
+/** Suggestion items. */
+export interface TurnSuggestionsNotification {
+    turnId: string;
+    items: Array<{
+        text: string;
+        icon?: string;
+        action?: string;
+    }>;
+}
+/** Sidechain started execution. */
+export interface TurnSidechainStartedNotification {
+    turnId: string;
+    depth: number;
+    role: string;
+}
+/** Sub-agent streaming text chunk. */
+export interface TurnSubagentDeltaNotification {
+    agentType: string;
+    subagentId?: string;
+    text: string;
+}
+/** Sidechain completed execution. */
+export interface TurnSidechainCompletedNotification {
+    turnId: string;
+    depth: number;
+    toolCallCount: number;
+}
+/** URL / file citations returned by OpenAI built-in tools. */
+export interface TurnAnnotationsNotification {
+    turnId: string;
+    annotations: Array<{
+        type: string;
+        url?: string;
+        title?: string;
+        [key: string]: unknown;
+    }>;
+}
+/** Structured media generation result. */
+export interface TurnMediaResultNotification {
+    turnId: string;
+    mediaType: MediaResultType;
+    url: string;
+    model?: string;
+    provider?: string;
+    durationSeconds?: number;
+    width?: number;
+    height?: number;
+    mimeType?: string;
+    billingUnit?: string;
+    billingQuantity?: number;
+    taskId?: string;
+}
+/** Async media generation progress. */
+export interface TurnMediaProgressNotification {
+    turnId: string;
+    taskId: string;
+    mediaType: MediaResultType;
+    percent: number;
+    status: string;
+    provider?: string;
+}
+/** Structured media provider usage for non-token billed image/video/audio calls. */
+export interface TurnMediaUsageNotification {
+    usageId: string;
+    turnId: string;
+    mediaType: MediaResultType | string;
+    provider: string;
+    model: string;
+    billingUnit: string;
+    billingQuantity: number;
+}
+/** Capability preflight decision for media requests. */
+export interface TurnMediaCapabilityCheckNotification {
+    turnId: string;
+    mediaType: MediaResultType | string;
+    provider: string;
+    model: string;
+    mode: string;
+    allowed: boolean;
+    reason?: string;
+    capabilities: {
+        modes: string[];
+        source: string;
+        limits: Record<string, unknown>;
+        features: Record<string, unknown>;
+    };
+}
+/** Media files auto-downloaded to local storage. */
+export interface TurnMediaPersistedNotification {
+    turnId: string;
+    files: Array<{
+        remoteUrl: string;
+        localPath: string;
+        bytes: number;
+        mimeType: string;
+    }>;
+}
+/** Task state change. */
+export interface TurnTaskUpdatedNotification {
+    turnId: string;
+    tasks: Array<{
+        id: string;
+        title: string;
+        status: string;
+    }>;
+}
+/** Real-time todo list update. */
+export interface TurnTodosUpdatedNotification {
+    turnId: string;
+    items: Array<{
+        id: number;
+        title: string;
+        status: string;
+        owner?: string;
+        blockedBy?: number[];
+    }>;
+    summary?: {
+        total: number;
+        completed: number;
+        inProgress: number;
+        notStarted: number;
+    };
+}
+/** Long-running command execution progress. */
+export interface TurnExecProgressNotification {
+    output: string;
+    elapsedTimeSeconds: number;
+    totalLines: number;
+    totalBytes: number;
+}
+/** Generic progress heartbeat. */
+export interface TurnHeartbeatNotification {
+    turnId: string;
+    message: string;
+}
+/** Human-readable summary of a tool use batch. */
+export interface TurnToolUseSummaryNotification {
+    turnId: string;
+    summary: string;
+}
+/** Structured artifact produced by the agent. */
+export interface TurnArtifactNotification {
+    turnId: string;
+    artifactId: string;
+    type: ArtifactType;
+    title: string;
+    filePath?: string;
+    language?: string;
+    content?: string;
+    mimeType?: string;
+}
+/** Agent requests user approval before executing a restricted tool. */
+export interface ToolApprovalRequestNotification {
+    approvalId: string;
+    callId: string;
+    toolName: string;
+    arguments: string;
+    message?: string;
+    suggestions?: string[];
+    category?: "cross_workspace" | "high_risk_delete" | "high_risk_egress" | "destructive";
+    reason?: string;
+    options?: Array<{
+        optionId: string;
+        name: string;
+        kind: string;
+        scope?: string;
+    }>;
+    rememberScope?: {
+        kind: "directory";
+        path: string;
+    };
+}
+/** Skill instruction directive. */
+export interface TurnSkillInstructionNotification {
+    turnId: string;
+    instruction: unknown;
+}
+/** Agent detected a repeating pattern that should be acquired as a skill from hub. */
+export interface TurnSkillAcquisitionNeededNotification {
+    turnId: string;
+    pattern: {
+        suggestedName: string;
+        description: string;
+        tools: string[];
+    };
+}
+/** Agent asks the user a clarifying question mid-turn. */
+export interface TurnAskUserNotification {
+    askId?: string;
+    requestId?: string;
+    questions: Array<{
+        header: string;
+        question: string;
+        options?: Array<{
+            label: string;
+            description?: string;
+        }>;
+    }>;
+}
+/** Memory content changed (local md or QMemory). */
+export interface MemoryUpdatedNotification {
+    source: string;
+    target?: string;
+    entryCount?: number;
+    summary?: string;
+}
+/** Skills list changed (activated/deactivated/learned/deleted). */
+export interface SkillsUpdatedNotification {
+    action: "activate" | "deactivate" | "delete" | "learn" | "promote";
+    name?: string;
+}
+/** Importance decay completed after Dream consolidation. */
+export interface MemoryDecayCompletedNotification {
+    decayed: number;
+    archived: number;
+    durationMs: number;
+}
+/** Session metadata changed. */
+export interface SessionInfoNotification {
+    sessionId: string;
+    title?: string;
+    model?: string;
+    provider?: string;
+    cwd?: string;
+    turnCount?: number;
+    pinnedAt?: string;
+    projectId?: string;
+}
+/** Permission rule saved/updated. */
+export interface PermissionRuleUpdatedNotification {
+    pattern: string;
+    behavior: string;
+    scope?: "session" | "persistent";
+}
+/** Forwarded notification from a team member child process. */
+export interface TeamMemberNotification {
+    memberId: string;
+    method: string;
+    params: unknown;
+}
+export interface PongNotification {
+}
+/** Real-time token usage update. */
+export interface TurnUsageUpdateNotification {
+    turnId: string;
+    usage: WireTokenUsage;
+    model?: string;
+    sessionCostUSD?: number;
+}
+/** Agent status change notification. */
+export interface AgentsStatusNotification {
+    agentId: string;
+    status: "available" | "spawning" | "running" | "hang" | "failed" | "unavailable";
+    health?: {
+        missedBeats: number;
+        lastActiveAt: string;
+    };
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    error?: {
+        phase: string;
+        message: string;
+        retriesLeft: number;
+    };
+}
+/** Agent error notification. */
+export interface AgentsErrorNotification {
+    agentId: string;
+    phase: "detect" | "spawn" | "handshake" | "runtime" | "shutdown" | "heartbeat";
+    error: string;
+    retriesLeft: number;
+}
+/** One-click install progress (state transitions + streamed log lines + final result). */
+export interface AgentInstallProgressNotification {
+    agentId: string;
+    event: {
+        type: "state";
+        state: "installing" | "verifying" | "installed" | "failed";
+    } | {
+        type: "log";
+        stream: "stdout" | "stderr";
+        chunk: string;
+    } | {
+        type: "done";
+        ok: boolean;
+        error?: string;
+    };
+}
+/**
+ * Live streaming chunk from an EXTERNAL agent's prompt turn (agents.prompt). Echoes the gateway's
+ * turn identity (sessionId/turnId/requestId passed in agents.prompt params) so the gateway can
+ * re-emit it on the same turn.delta path the main agent uses — no separate frontend handling.
+ */
+export interface AgentsPromptDeltaNotification {
+    agentId: string;
+    sessionId?: string;
+    turnId?: string;
+    requestId?: string;
+    text: string;
+    /** When true this chunk is the agent's reasoning/thinking (→ turn.reasoning_delta), not reply text. */
+    reasoning?: boolean;
+}
+/**
+ * Live tool-call lifecycle from an EXTERNAL agent's prompt turn — same echo-the-turn-identity
+ * mechanism as AgentsPromptDeltaNotification, so the gateway re-emits it on the main
+ * turn.tool_call / turn.tool_result path and the UI shows external tools running, no extra handling.
+ */
+export interface AgentsPromptToolNotification {
+    agentId: string;
+    sessionId?: string;
+    turnId?: string;
+    requestId?: string;
+    event: {
+        kind: "call";
+        callId: string;
+        name: string;
+        arguments?: string;
+        inputSummary?: string;
+    } | {
+        kind: "result";
+        callId: string;
+        name: string;
+        ok: boolean;
+        outputPreview?: string;
+        error?: string;
+    };
+}
+/**
+ * Plan/task update from an EXTERNAL agent's prompt turn (ACP plan steps). The gateway maps the
+ * steps onto the main turn.task_updated path so the UI shows the agent's plan as a task list.
+ */
+export interface AgentsPromptPlanNotification {
+    agentId: string;
+    sessionId?: string;
+    turnId?: string;
+    requestId?: string;
+    steps: Array<{
+        content?: string;
+        title?: string;
+        status?: string;
+        priority?: string;
+    }>;
+}
+/**
+ * Interactive permission request from an EXTERNAL agent's prompt turn. Echoes the gateway's turn
+ * identity so the gateway re-emits it on the main turn.approval_request path → the UI shows an
+ * approval card; the user's decision returns via the agents.approvalResponse RPC.
+ */
+export interface AgentsPromptApprovalNotification {
+    agentId: string;
+    sessionId?: string;
+    turnId?: string;
+    requestId?: string;
+    approvalId: string;
+    callId?: string;
+    toolName: string;
+    arguments?: string;
+    message?: string;
+    category?: string;
+    options?: Array<{
+        optionId: string;
+        name?: string;
+        kind?: string;
+    }>;
+}
+/** Solo agent progress. */
+export interface SoloProgressNotification {
+    soloId: string;
+    agentId: string;
+    state: "pending" | "running" | "completed" | "failed" | "idle";
+    progress?: string;
+}
+/** Solo evaluation completed. */
+export interface SoloEvaluationNotification {
+    soloId: string;
+    winnerId: string;
+    reasoning: string;
+}
+/** Solo agent streaming delta. */
+export interface SoloAgentDeltaNotification {
+    soloId: string;
+    agentId: string;
+    text: string;
+}
+/** Solo agent diff. */
+export interface SoloAgentDiffNotification {
+    soloId: string;
+    agentId: string;
+    files: {
+        path: string;
+        hunks: string;
+    }[];
+}
+/** Solo agent usage. */
+export interface SoloAgentUsageNotification {
+    soloId: string;
+    agentId: string;
+    inputTokens: number;
+    outputTokens: number;
+}
+/** Product task started. */
+export interface ProductTaskStartedNotification {
+    productId: string;
+    taskId: string;
+    assignee: string;
+}
+/** Product task completed. */
+export interface ProductTaskCompletedNotification {
+    productId: string;
+    taskId: string;
+    result: string;
+}
+/** Product task failed. */
+export interface ProductTaskFailedNotification {
+    productId: string;
+    taskId: string;
+    error: string;
+}
+/** Product checkpoint saved. */
+export interface ProductCheckpointedNotification {
+    productId: string;
+    timestamp: string;
+}
+/** Product budget warning (>80%). */
+export interface ProductBudgetWarningNotification {
+    productId: string;
+    usedTokens: number;
+    maxTotalTokens: number;
+    percentage: number;
+}
+/** Product completed (all tasks done or terminal). */
+export interface ProductCompletedNotification {
+    productId: string;
+    summary: string;
+}
+/** Product DAG topology. */
+export interface ProductDagTopologyNotification {
+    productId: string;
+    nodes: {
+        id: string;
+        label: string;
+        deps: string[];
+    }[];
+    edges: {
+        from: string;
+        to: string;
+    }[];
+}
+/** Product budget update. */
+export interface ProductBudgetUpdateNotification {
+    productId: string;
+    inputTokens: number;
+    outputTokens: number;
+    elapsed: number;
+    maxTotalTokens?: number;
+}
+/** Product task output delta. */
+export interface ProductTaskOutputDeltaNotification {
+    productId: string;
+    taskId: string;
+    text: string;
+}
+/** Leader agent produced a structured plan — client should present to user. */
+export interface ProductPlanReadyNotification {
+    productId: string;
+    plan: {
+        name: string;
+        modules: Array<{
+            name: string;
+            description: string;
+            suggestedAgentId?: string;
+        }>;
+        instances: Array<{
+            name: string;
+            agentId: string;
+            role: string;
+        }>;
+        tasks: Array<{
+            taskId: string;
+            assignee: string;
+            prompt: string;
+            dependsOn?: string[];
+        }>;
+        reasoning: string;
+    };
+}
+/** Planning failed. */
+export interface ProductPlanFailedNotification {
+    productId: string;
+    error: string;
+}
+/** Streaming text output from leader during planning. */
+export interface ProductPlanningDeltaNotification {
+    productId: string;
+    text: string;
+}
+/** Plan interrupted. */
+export interface PlanInterruptedNotification {
+    planId: string;
+    /** The project type (solo/product) of the interrupted plan */
+    projectType: "solo" | "product";
+    reason: string;
+}
+/** A project was created. */
+export interface ProjectCreatedNotification {
+    id: string;
+    name: string;
+    workspaceDir: string;
+    type: string;
+    groupId?: string;
+}
+/** Active project was switched. */
+export interface ProjectSwitchedNotification {
+    id: string;
+    name: string;
+    workspaceDir: string;
+}
+/** A project was deleted. */
+export interface ProjectDeletedNotification {
+    id: string;
+}
+/** A project was renamed. */
+export interface ProjectRenamedNotification {
+    id: string;
+    name: string;
+    workspaceDir: string;
+}
+/** A project was archived. */
+export interface ProjectArchivedNotification {
+    id: string;
+}
+/** A project was unarchived (restored). */
+export interface ProjectUnarchivedNotification {
+    id: string;
+    name: string;
+    workspaceDir: string;
+}
+/** A sub-agent was spawned. */
+export interface TurnSubagentStartedNotification {
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    prompt?: string;
+}
+/** A sub-agent finished. */
+export interface TurnSubagentEndedNotification {
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    ok: boolean;
+    outputPreview?: string;
+    error?: string;
+}
+/** A task lifecycle state changed. */
+export interface TaskUpdatedNotification {
+    taskId: string;
+    type: string;
+    lifecycle: string;
+    label?: string;
+}
+/** Team member state changed (idle/busy/error/exited). */
+export interface TeamMemberStateNotification {
+    memberId: string;
+    state: string;
+}
+/** Team created/destroyed. */
+export interface TeamUpdatedNotification {
+    teamName: string;
+    action: string;
+    members: Array<{
+        agentName: string;
+        role: string;
+        worktreePath?: string;
+        pid?: number;
+    }>;
+}
+/** Emitted when pet soul is hatched/ready. */
+export interface PetSoulReadyNotification {
+    name: string;
+    species: string;
+    personality: string;
+    catchphrase: string;
+    stats: {
+        grip: number;
+        patience: number;
+        curiosity: number;
+        appetite: number;
+        humor: number;
+    };
+    rarity: string;
+    breed?: string;
+    breedColors?: {
+        primary: string;
+        secondary: string;
+    };
+}
+/** Emitted with a reaction text for the pet speech bubble. */
+export interface PetReactionNotification {
+    text: string;
+    style: "normal" | "thinking" | "excited" | "sleepy";
+    duration?: number;
+}
+/** Emitted when pet gains XP or levels up. */
+export interface PetGrowthNotification {
+    level: number;
+    experience: number;
+    xpNeeded?: number;
+    displayTraits?: Array<{
+        id: string;
+        level: number;
+    }>;
+    nextDisplayTrait?: {
+        id: string;
+        level: number;
+    };
+}
+/** Emitted to override pet state from agent side. */
+export interface PetStateNotification {
+    state: string;
+}
+/** Emitted when agent needs user confirmation for a tool call (design §8 PetConfirmWindow). */
+export interface PetConfirmNotification {
+    confirmId: string;
+    toolName: string;
+    description: string;
+    risk: ToolRiskLevel;
+    timeoutMs?: number;
+}
+export interface PetAssetUpdatedNotification {
+    asset: {
+        id: string;
+        assetKind: "petdex";
+        name: string;
+        description: string;
+        createdAt: string;
+        updatedAt: string;
+        atlas: {
+            format: "webp";
+            columns: 8;
+            rows: 9;
+            frameCount: 72;
+            cellWidth: 192;
+            cellHeight: 208;
+            width: 1536;
+            height: 1872;
+            sha256: string;
+            imageUrl?: string;
+        };
+        animations?: Record<string, {
+            frames: number[];
+            fps: number;
+            loop: boolean;
+        }>;
+        sourcePrompt?: string;
+    };
+}
+export interface SystemActivityNotification {
+    category: "dream" | "cron" | "decay" | "system";
+    level: "info" | "warn" | "error" | "success";
+    title: string;
+    detail?: string;
+}
+export interface WorkflowRecordNotification {
+    workflow: {
+        id: string;
+        name: string;
+        active: boolean;
+        concurrency: string;
+        rev: number;
+        createdAt: string;
+        updatedAt: string;
+        trigger?: unknown;
+        def: unknown;
+    };
+}
+export interface WorkflowDeletedNotification {
+    workflowId: string;
+}
+export interface WorkflowRunStartedNotification {
+    workflowId: string;
+    triggerType: string;
+}
+export interface WorkflowRunCompletedNotification {
+    workflowId: string;
+    status: "completed" | "paused" | "skipped";
+    triggerType: string;
+    outcome?: unknown;
+}
+export interface WorkflowRunFailedNotification {
+    workflowId: string;
+    triggerType?: string;
+    error: string;
+    outcome?: unknown;
+}
+export interface NotificationMethodMap {
+    "turn.start": TurnStartNotification;
+    "turn.delta": TurnDeltaNotification;
+    "turn.end": TurnEndNotification;
+    "turn.error": TurnErrorNotification;
+    "turn.recovery": TurnRecoveryNotification;
+    "turn.tool_call": TurnToolCallNotification;
+    "turn.tool_result": TurnToolResultNotification;
+    "turn.tool_blocked": TurnToolBlockedNotification;
+    "turn.reasoning_delta": TurnReasoningDeltaNotification;
+    "turn.plan_update": TurnPlanUpdateNotification;
+    "turn.suggestions": TurnSuggestionsNotification;
+    "turn.sidechain_started": TurnSidechainStartedNotification;
+    "turn.subagent_delta": TurnSubagentDeltaNotification;
+    "turn.sidechain_completed": TurnSidechainCompletedNotification;
+    "turn.subagent_started": TurnSubagentStartedNotification;
+    "turn.subagent_ended": TurnSubagentEndedNotification;
+    "turn.annotations": TurnAnnotationsNotification;
+    "turn.media_result": TurnMediaResultNotification;
+    "turn.media_progress": TurnMediaProgressNotification;
+    "turn.media_usage": TurnMediaUsageNotification;
+    "turn.media_capability_check": TurnMediaCapabilityCheckNotification;
+    "turn.media_persisted": TurnMediaPersistedNotification;
+    "turn.task_updated": TurnTaskUpdatedNotification;
+    "turn.todos_updated": TurnTodosUpdatedNotification;
+    "task.updated": TaskUpdatedNotification;
+    "turn.exec_progress": TurnExecProgressNotification;
+    "turn.heartbeat": TurnHeartbeatNotification;
+    "turn.tool_use_summary": TurnToolUseSummaryNotification;
+    "turn.artifact": TurnArtifactNotification;
+    "tool.approval.request": ToolApprovalRequestNotification;
+    "turn.skill_instruction": TurnSkillInstructionNotification;
+    "turn.skill_acquisition_needed": TurnSkillAcquisitionNeededNotification;
+    "turn.ask_user": TurnAskUserNotification;
+    "memory.updated": MemoryUpdatedNotification;
+    "memory.decay.completed": MemoryDecayCompletedNotification;
+    "skills.updated": SkillsUpdatedNotification;
+    "session.info": SessionInfoNotification;
+    "permission.rule_updated": PermissionRuleUpdatedNotification;
+    "team.member.notification": TeamMemberNotification;
+    "team.member.state": TeamMemberStateNotification;
+    "team.updated": TeamUpdatedNotification;
+    "turn.usage_update": TurnUsageUpdateNotification;
+    "pong": PongNotification;
+    "agents.status": AgentsStatusNotification;
+    "agents.error": AgentsErrorNotification;
+    "agent.install.progress": AgentInstallProgressNotification;
+    "agents.prompt.delta": AgentsPromptDeltaNotification;
+    "agents.prompt.tool": AgentsPromptToolNotification;
+    "agents.prompt.approval": AgentsPromptApprovalNotification;
+    "agents.prompt.plan": AgentsPromptPlanNotification;
+    "solo.progress": SoloProgressNotification;
+    "solo.evaluation": SoloEvaluationNotification;
+    "solo.agentDelta": SoloAgentDeltaNotification;
+    "solo.agentDiff": SoloAgentDiffNotification;
+    "solo.agentUsage": SoloAgentUsageNotification;
+    "product.taskStarted": ProductTaskStartedNotification;
+    "product.taskCompleted": ProductTaskCompletedNotification;
+    "product.taskFailed": ProductTaskFailedNotification;
+    "product.checkpointed": ProductCheckpointedNotification;
+    "product.budgetWarning": ProductBudgetWarningNotification;
+    "product.completed": ProductCompletedNotification;
+    "product.dagTopology": ProductDagTopologyNotification;
+    "product.budgetUpdate": ProductBudgetUpdateNotification;
+    "product.taskOutput": ProductTaskOutputDeltaNotification;
+    "product.planReady": ProductPlanReadyNotification;
+    "product.planFailed": ProductPlanFailedNotification;
+    "product.planningDelta": ProductPlanningDeltaNotification;
+    "plan.interrupted": PlanInterruptedNotification;
+    "project.created": ProjectCreatedNotification;
+    "project.switched": ProjectSwitchedNotification;
+    "project.deleted": ProjectDeletedNotification;
+    "project.renamed": ProjectRenamedNotification;
+    "project.archived": ProjectArchivedNotification;
+    "project.unarchived": ProjectUnarchivedNotification;
+    "pet.soul_ready": PetSoulReadyNotification;
+    "pet.reaction": PetReactionNotification;
+    "pet.growth": PetGrowthNotification;
+    "pet.state": PetStateNotification;
+    "pet.confirm": PetConfirmNotification;
+    "pet.asset.updated": PetAssetUpdatedNotification;
+    "system.activity": SystemActivityNotification;
+    "workflow.created": WorkflowRecordNotification;
+    "workflow.updated": WorkflowRecordNotification;
+    "workflow.deleted": WorkflowDeletedNotification;
+    "workflow.runStarted": WorkflowRunStartedNotification;
+    "workflow.runCompleted": WorkflowRunCompletedNotification;
+    "workflow.runFailed": WorkflowRunFailedNotification;
+}
+/** All known notification method names. */
+export type NotificationMethod = keyof NotificationMethodMap;