@yaklabs-ai/plugin-sdk 0.53.0 → 0.54.1

package/dist/kay-app.d.ts

@@ -124,6 +124,1006 @@ declare function AddReadonlyDeferred<Type extends TSchema>(type: Type, options?:
  */
 declare type AgentMessage = Message | CustomAgentMessages[keyof CustomAgentMessages];
 
+declare const AgentRuntimeArtifact: z.ZodObject<{
+    uri: z.ZodString;
+    kind: z.ZodString;
+    name: z.ZodString;
+    title: z.ZodString;
+    updatedAtMs: z.ZodNumber;
+    mimeType: z.ZodOptional<z.ZodString>;
+    sizeBytes: z.ZodOptional<z.ZodNumber>;
+    committedVersionState: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"draft">;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"clean">;
+        committedVersion: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"edited">;
+        committedVersion: z.ZodNumber;
+    }, z.core.$strict>], "state">>;
+}, z.core.$strict>;
+
+declare type AgentRuntimeArtifact = z.infer<typeof AgentRuntimeArtifact>;
+
+declare const AgentRuntimeAutomationFactSource: z.ZodEnum<{
+    "run-settled": "run-settled";
+    "tool-used": "tool-used";
+    "tool-failed": "tool-failed";
+}>;
+
+declare type AgentRuntimeAutomationFactSource = z.infer<typeof AgentRuntimeAutomationFactSource>;
+
+/** One automation run's provenance detail (RFC Release 2). */
+declare const AgentRuntimeAutomationRunDetail: z.ZodObject<{
+    run: z.ZodObject<{
+        id: z.ZodString;
+        bindingId: z.ZodString;
+        logicalKey: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            running: "running";
+            succeeded: "succeeded";
+            queued: "queued";
+            skipped: "skipped";
+            claimed: "claimed";
+        }>;
+        match: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"plugin-event">;
+            event: z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                version: z.ZodNumber;
+                uri: z.ZodString;
+                occurredAt: z.ZodISODateTime;
+                publishedAt: z.ZodISODateTime;
+                source: z.ZodObject<{
+                    layer: z.ZodLiteral<"runtime">;
+                    runId: z.ZodOptional<z.ZodString>;
+                    pluginId: z.ZodString;
+                    poller: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"time">;
+            scheduledAtMs: z.ZodNumber;
+            zone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            factId: z.ZodString;
+            source: z.ZodEnum<{
+                "run-settled": "run-settled";
+                "tool-used": "tool-used";
+                "tool-failed": "tool-failed";
+            }>;
+            sessionId: z.ZodString;
+            occurredAtMs: z.ZodNumber;
+            toolName: z.ZodOptional<z.ZodString>;
+            uriScheme: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"occurrence">;
+        }, z.core.$strict>, z.ZodObject<{
+            dueAtMs: z.ZodNumber;
+            factId: z.ZodString;
+            source: z.ZodEnum<{
+                "run-settled": "run-settled";
+                "tool-used": "tool-used";
+                "tool-failed": "tool-failed";
+            }>;
+            sessionId: z.ZodString;
+            occurredAtMs: z.ZodNumber;
+            toolName: z.ZodOptional<z.ZodString>;
+            uriScheme: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"delayed-occurrence">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"uri-change">;
+            scheduledAtMs: z.ZodNumber;
+            uri: z.ZodString;
+            digest: z.ZodString;
+            previousDigest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"manual">;
+            requestedAtMs: z.ZodNumber;
+            referenceAtMs: z.ZodOptional<z.ZodNumber>;
+            requestId: z.ZodOptional<z.ZodString>;
+            requestedBy: z.ZodOptional<z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+            }>>;
+        }, z.core.$strict>], "kind">;
+        generation: z.ZodString;
+        claimedAtMs: z.ZodNumber;
+        startedAtMs: z.ZodOptional<z.ZodNumber>;
+        settledAtMs: z.ZodOptional<z.ZodNumber>;
+        outcome: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"succeeded">;
+            summary: z.ZodOptional<z.ZodObject<{
+                headline: z.ZodString;
+                details: z.ZodOptional<z.ZodString>;
+                author: z.ZodEnum<{
+                    automation: "automation";
+                    kay: "kay";
+                }>;
+            }, z.core.$strict>>;
+            daemonRunId: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            script: z.ZodOptional<z.ZodObject<{
+                sourceDigest: z.ZodString;
+            }, z.core.$strict>>;
+            tries: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"failed">;
+            summary: z.ZodOptional<z.ZodObject<{
+                headline: z.ZodString;
+                details: z.ZodOptional<z.ZodString>;
+                author: z.ZodEnum<{
+                    automation: "automation";
+                    kay: "kay";
+                }>;
+            }, z.core.$strict>>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                surface_unavailable: "surface_unavailable";
+                owner_missing: "owner_missing";
+                target_missing: "target_missing";
+                declaration_gone: "declaration_gone";
+                executor_failed: "executor_failed";
+                permission_denied: "permission_denied";
+            }>>;
+            message: z.ZodOptional<z.ZodString>;
+            classification: z.ZodOptional<z.ZodObject<{
+                code: z.ZodEnum<{
+                    runtime_interrupted: "runtime_interrupted";
+                    surface_unavailable: "surface_unavailable";
+                    provider_auth_failed: "provider_auth_failed";
+                    provider_rate_limited: "provider_rate_limited";
+                    provider_unavailable: "provider_unavailable";
+                    provider_stream_terminated: "provider_stream_terminated";
+                    provider_unreachable: "provider_unreachable";
+                    provider_quota_exhausted: "provider_quota_exhausted";
+                    provider_seat_unpaid: "provider_seat_unpaid";
+                    provider_model_disabled: "provider_model_disabled";
+                    bonsai_sign_in_required: "bonsai_sign_in_required";
+                    bonsai_organization_unavailable: "bonsai_organization_unavailable";
+                    bonsai_account_unreachable: "bonsai_account_unreachable";
+                    run_cancelled: "run_cancelled";
+                    provider_request_rejected: "provider_request_rejected";
+                    run_final_output_missing: "run_final_output_missing";
+                    turn_failed: "turn_failed";
+                    workflow_failed: "workflow_failed";
+                    turn_delivery_failed: "turn_delivery_failed";
+                    handler_failed: "handler_failed";
+                    network_unreachable: "network_unreachable";
+                    surface_starting: "surface_starting";
+                    script_unreadable: "script_unreadable";
+                    owner_missing: "owner_missing";
+                    owner_unsupported: "owner_unsupported";
+                    turn_target_missing: "turn_target_missing";
+                    target_missing: "target_missing";
+                    declaration_gone: "declaration_gone";
+                    script_timed_out: "script_timed_out";
+                    script_killed: "script_killed";
+                    script_crashed: "script_crashed";
+                    script_tool_call_failed: "script_tool_call_failed";
+                    script_tool_call_aborted: "script_tool_call_aborted";
+                    script_tool_call_blocked: "script_tool_call_blocked";
+                    script_tool_response_not_json: "script_tool_response_not_json";
+                    script_exited_nonzero: "script_exited_nonzero";
+                    script_runtime_missing: "script_runtime_missing";
+                    script_cwd_missing: "script_cwd_missing";
+                    script_cwd_unset: "script_cwd_unset";
+                    script_cwd_deleted: "script_cwd_deleted";
+                    script_process_failed: "script_process_failed";
+                    script_result_invalid: "script_result_invalid";
+                    script_failed: "script_failed";
+                }>;
+                category: z.ZodEnum<{
+                    unknown: "unknown";
+                    cancelled: "cancelled";
+                    auth: "auth";
+                    network: "network";
+                    rate_limit: "rate_limit";
+                    provider: "provider";
+                }>;
+                retryable: z.ZodBoolean;
+                retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            failure: z.ZodOptional<z.ZodType<RunFailureOccurrence, unknown, z.core.$ZodTypeInternals<RunFailureOccurrence, unknown>>>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            retryAtMs: z.ZodOptional<z.ZodNumber>;
+            tries: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodEnum<{
+                already_running: "already_running";
+                binding_inactive: "binding_inactive";
+                guard_not_satisfied: "guard_not_satisfied";
+                missed_window: "missed_window";
+                timer_cancelled: "timer_cancelled";
+            }>;
+        }, z.core.$strict>], "status">>;
+        resumes: z.ZodOptional<z.ZodString>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        economics: z.ZodOptional<z.ZodObject<{
+            attempt: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                amountUsd: z.ZodNumber;
+                coverage: z.ZodObject<{
+                    attributedTurns: z.ZodNumber;
+                    pricedTurns: z.ZodNumber;
+                    attributedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                    pricedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                state: z.ZodLiteral<"exact">;
+            }, z.core.$strict>, z.ZodObject<{
+                amountUsd: z.ZodNumber;
+                coverage: z.ZodObject<{
+                    attributedTurns: z.ZodNumber;
+                    pricedTurns: z.ZodNumber;
+                    attributedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                    pricedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                state: z.ZodLiteral<"lower_bound">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"rebuilding">;
+                coverage: z.ZodObject<{
+                    attributedTurns: z.ZodNumber;
+                    pricedTurns: z.ZodNumber;
+                    attributedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                    pricedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"unavailable">;
+                coverage: z.ZodObject<{
+                    attributedTurns: z.ZodNumber;
+                    pricedTurns: z.ZodNumber;
+                    attributedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                    pricedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "state">;
+            chain: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                amountUsd: z.ZodNumber;
+                coverage: z.ZodObject<{
+                    attributedTurns: z.ZodNumber;
+                    pricedTurns: z.ZodNumber;
+                    attributedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                    pricedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                state: z.ZodLiteral<"exact">;
+            }, z.core.$strict>, z.ZodObject<{
+                amountUsd: z.ZodNumber;
+                coverage: z.ZodObject<{
+                    attributedTurns: z.ZodNumber;
+                    pricedTurns: z.ZodNumber;
+                    attributedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                    pricedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                state: z.ZodLiteral<"lower_bound">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"rebuilding">;
+                coverage: z.ZodObject<{
+                    attributedTurns: z.ZodNumber;
+                    pricedTurns: z.ZodNumber;
+                    attributedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                    pricedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"unavailable">;
+                coverage: z.ZodObject<{
+                    attributedTurns: z.ZodNumber;
+                    pricedTurns: z.ZodNumber;
+                    attributedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                    pricedDirectCalls: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "state">;
+        }, z.core.$strict>>;
+        changes: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"exact">;
+            artifactTargetCount: z.ZodNumber;
+            producedResourceCount: z.ZodNumber;
+            asOfMs: z.ZodNumber;
+            gaps: z.ZodArray<z.ZodObject<{
+                code: z.ZodEnum<{
+                    "legacy-run-id-missing": "legacy-run-id-missing";
+                    "mutation-revision-missing": "mutation-revision-missing";
+                    "partial-git-provenance": "partial-git-provenance";
+                    "git-session-stamp-missing": "git-session-stamp-missing";
+                    "external-resource-unnamed": "external-resource-unnamed";
+                    "produced-resource-unnamed": "produced-resource-unnamed";
+                    "skill-suggestion-unattributable": "skill-suggestion-unattributable";
+                    "malformed-source-record": "malformed-source-record";
+                    "source-unreadable": "source-unreadable";
+                    "git-revision-unavailable": "git-revision-unavailable";
+                    "automation-history-unavailable": "automation-history-unavailable";
+                    "session-history-unavailable": "session-history-unavailable";
+                    "required-evidence-missing": "required-evidence-missing";
+                }>;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodEnum<{
+                partial: "partial";
+                rebuilding: "rebuilding";
+            }>;
+            asOfMs: z.ZodNumber;
+            gaps: z.ZodArray<z.ZodObject<{
+                code: z.ZodEnum<{
+                    "legacy-run-id-missing": "legacy-run-id-missing";
+                    "mutation-revision-missing": "mutation-revision-missing";
+                    "partial-git-provenance": "partial-git-provenance";
+                    "git-session-stamp-missing": "git-session-stamp-missing";
+                    "external-resource-unnamed": "external-resource-unnamed";
+                    "produced-resource-unnamed": "produced-resource-unnamed";
+                    "skill-suggestion-unattributable": "skill-suggestion-unattributable";
+                    "malformed-source-record": "malformed-source-record";
+                    "source-unreadable": "source-unreadable";
+                    "git-revision-unavailable": "git-revision-unavailable";
+                    "automation-history-unavailable": "automation-history-unavailable";
+                    "session-history-unavailable": "session-history-unavailable";
+                    "required-evidence-missing": "required-evidence-missing";
+                }>;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unavailable">;
+        }, z.core.$strict>], "state">>;
+    }, z.core.$strict>;
+    activity: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            sessionId: z.ZodString;
+            sessionRunId: z.ZodString;
+            kind: z.ZodEnum<{
+                direct: "direct";
+                child: "child";
+            }>;
+            shared: z.ZodBoolean;
+            session: z.ZodObject<{
+                sessionId: z.ZodString;
+                agentId: z.ZodOptional<z.ZodString>;
+                parentSessionId: z.ZodNullable<z.ZodString>;
+                predecessorSessionId: z.ZodNullable<z.ZodString>;
+                openedBySessionId: z.ZodNullable<z.ZodString>;
+                rootSessionId: z.ZodString;
+                spawnDepth: z.ZodNumber;
+                cwd: z.ZodOptional<z.ZodString>;
+                displayTitle: z.ZodOptional<z.ZodString>;
+                userTitle: z.ZodOptional<z.ZodString>;
+                stewardTitle: z.ZodOptional<z.ZodString>;
+                stewardCommentary: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                stewardNextSteps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                stewardCompactionSuggested: z.ZodOptional<z.ZodLiteral<true>>;
+                stewardSuggestedModelTier: z.ZodOptional<z.ZodEnum<{
+                    small: "small";
+                    medium: "medium";
+                    large: "large";
+                    ultra: "ultra";
+                }>>;
+                provider: z.ZodOptional<z.ZodString>;
+                modelReference: z.ZodOptional<z.ZodString>;
+                modelAccountName: z.ZodOptional<z.ZodString>;
+                modelSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"specific">;
+                    modelReference: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"tier">;
+                    tierId: z.ZodEnum<{
+                        small: "small";
+                        medium: "medium";
+                        large: "large";
+                        ultra: "ultra";
+                    }>;
+                    provider: z.ZodOptional<z.ZodString>;
+                    constraints: z.ZodOptional<z.ZodObject<{
+                        provider: z.ZodOptional<z.ZodString>;
+                        vendor: z.ZodOptional<z.ZodString>;
+                        notVendor: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"model">;
+                    model: z.ZodString;
+                    constraints: z.ZodOptional<z.ZodObject<{
+                        provider: z.ZodOptional<z.ZodString>;
+                        vendor: z.ZodOptional<z.ZodString>;
+                        notVendor: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>], "kind">>;
+                activeToolNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    default: "default";
+                    auto: "auto";
+                    ask: "ask";
+                    allow: "allow";
+                }>>;
+                thinkingLevel: z.ZodOptional<z.ZodEnum<{
+                    max: "max";
+                    off: "off";
+                    minimal: "minimal";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    xhigh: "xhigh";
+                }>>;
+                processingSpeed: z.ZodOptional<z.ZodEnum<{
+                    standard: "standard";
+                    fast: "fast";
+                }>>;
+                artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    uri: z.ZodString;
+                    kind: z.ZodString;
+                    name: z.ZodString;
+                    title: z.ZodString;
+                    updatedAtMs: z.ZodNumber;
+                    mimeType: z.ZodOptional<z.ZodString>;
+                    sizeBytes: z.ZodOptional<z.ZodNumber>;
+                    committedVersionState: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        state: z.ZodLiteral<"draft">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        state: z.ZodLiteral<"clean">;
+                        committedVersion: z.ZodNumber;
+                    }, z.core.$strict>, z.ZodObject<{
+                        state: z.ZodLiteral<"edited">;
+                        committedVersion: z.ZodNumber;
+                    }, z.core.$strict>], "state">>;
+                }, z.core.$strict>>>;
+                running: z.ZodBoolean;
+                runState: z.ZodOptional<z.ZodEnum<{
+                    interrupted: "interrupted";
+                    cancelled: "cancelled";
+                    completed: "completed";
+                    failed: "failed";
+                    running: "running";
+                }>>;
+                origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"user">;
+                    surface: z.ZodOptional<z.ZodString>;
+                    onboardingAttemptId: z.ZodOptional<z.ZodUUID>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"subagent">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"system">;
+                    surface: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"followup">;
+                    parentSessionId: z.ZodString;
+                    surface: z.ZodString;
+                    forkedAtEntryId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>], "kind">;
+                createdAt: z.ZodOptional<z.ZodISODateTime>;
+                updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                runStartedAt: z.ZodOptional<z.ZodNumber>;
+                runSettledAt: z.ZodOptional<z.ZodNumber>;
+                detachedWorkStartedAt: z.ZodOptional<z.ZodNumber>;
+                state: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodEnum<{
+                        failed: "failed";
+                        running: "running";
+                        needs_you: "needs_you";
+                        waiting: "waiting";
+                        idle: "idle";
+                    }>;
+                    since: z.ZodISODateTime;
+                }, z.core.$strict>>;
+                lastSeenAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                archivedAtMs: z.ZodOptional<z.ZodNumber>;
+                pinnedAtMs: z.ZodOptional<z.ZodNumber>;
+                deletedAtMs: z.ZodOptional<z.ZodNumber>;
+                remotePeerId: z.ZodOptional<z.ZodString>;
+                provenance: z.ZodOptional<z.ZodObject<{
+                    relationships: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"child-of">;
+                        sessionId: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"forked-from">;
+                        sessionId: z.ZodString;
+                        atEntryId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>], "kind">>;
+                    createdBy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"human">;
+                        surface: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"agent">;
+                        sessionId: z.ZodString;
+                        tool: z.ZodString;
+                        runId: z.ZodOptional<z.ZodString>;
+                        toolCallId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"plugin">;
+                        pluginId: z.ZodString;
+                        door: z.ZodEnum<{
+                            "sessions.create": "sessions.create";
+                            "sessions.run": "sessions.run";
+                            "hindsight.runFollowup": "hindsight.runFollowup";
+                            "agents.run": "agents.run";
+                        }>;
+                        callerSessionId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"trigger">;
+                        automationId: z.ZodString;
+                        runId: z.ZodOptional<z.ZodString>;
+                        bindingName: z.ZodString;
+                        triggerKind: z.ZodEnum<{
+                            time: "time";
+                            cron: "cron";
+                            occurrence: "occurrence";
+                            "uri-change": "uri-change";
+                            "plugin-event": "plugin-event";
+                            manual: "manual";
+                        }>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"daemon">;
+                        capability: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    definedBy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        layer: z.ZodLiteral<"plugin">;
+                        pluginId: z.ZodString;
+                        capability: z.ZodString;
+                        version: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        layer: z.ZodLiteral<"host">;
+                        capability: z.ZodString;
+                    }, z.core.$strict>], "layer">;
+                    intent: z.ZodEnum<{
+                        interactive: "interactive";
+                        headless: "headless";
+                    }>;
+                    causedByEvent: z.ZodOptional<z.ZodObject<{
+                        handler: z.ZodString;
+                        kind: z.ZodOptional<z.ZodEnum<{
+                            "session-event": "session-event";
+                            backfill: "backfill";
+                        }>>;
+                        event: z.ZodOptional<z.ZodObject<{
+                            type: z.ZodEnum<{
+                                "turn-settled": "turn-settled";
+                                "phase-shift": "phase-shift";
+                                "human-message": "human-message";
+                                "assistant-message": "assistant-message";
+                                "ui-action": "ui-action";
+                            }>;
+                            entryId: z.ZodString;
+                            runId: z.ZodOptional<z.ZodString>;
+                            throughEntryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        }, z.core.$strict>>;
+                        dedupeKey: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                projectId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        totalCount: z.ZodNumber;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    artifacts: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            uri: z.ZodString;
+            moduleId: z.ZodString;
+            sessionId: z.ZodString;
+            action: z.ZodEnum<{
+                created: "created";
+                updated: "updated";
+                deleted: "deleted";
+            }>;
+            revision: z.ZodString;
+            revisionCount: z.ZodNumber;
+            offBranch: z.ZodBoolean;
+            shared: z.ZodBoolean;
+        }, z.core.$strict>>;
+        totalCount: z.ZodNumber;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    externalResources: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            kind: z.ZodEnum<{
+                "github-pr": "github-pr";
+            }>;
+            sessionId: z.ZodString;
+            shared: z.ZodBoolean;
+        }, z.core.$strict>>;
+        totalCount: z.ZodNumber;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    producedResources: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            uri: z.ZodString;
+            action: z.ZodEnum<{
+                created: "created";
+                updated: "updated";
+                deleted: "deleted";
+            }>;
+            sessionId: z.ZodString;
+            revision: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                count: z.ZodNumber;
+            }, z.core.$strict>>;
+            offBranch: z.ZodBoolean;
+            shared: z.ZodBoolean;
+        }, z.core.$strict>>;
+        totalCount: z.ZodNumber;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    suggestions: z.ZodObject<{
+        items: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            sourceId: z.ZodString;
+            skillName: z.ZodString;
+            suggestionId: z.ZodString;
+            kind: z.ZodEnum<{
+                new: "new";
+                improvement: "improvement";
+            }>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                declined: "declined";
+                accepted: "accepted";
+            }>;
+            baseLocalRevision: z.ZodString;
+            candidateRevision: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodOptional<z.ZodUnknown>;
+            summary: z.ZodOptional<z.ZodString>;
+            why: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+            locatorVersion: z.ZodOptional<z.ZodUnknown>;
+            sessionId: z.ZodString;
+            shared: z.ZodBoolean;
+        }, z.core.$strict>, z.ZodObject<{
+            locatorVersion: z.ZodOptional<z.ZodUnknown>;
+            sessionId: z.ZodString;
+            shared: z.ZodBoolean;
+            sourceId: z.ZodString;
+            skillName: z.ZodString;
+            suggestionId: z.ZodString;
+            kind: z.ZodEnum<{
+                new: "new";
+                improvement: "improvement";
+            }>;
+            status: z.ZodLiteral<"unavailable">;
+            candidateRevision: z.ZodString;
+        }, z.core.$strict>]>>;
+        totalCount: z.ZodNumber;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    coverage: z.ZodObject<{
+        state: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+        }>;
+        asOfMs: z.ZodNumber;
+        stamp: z.ZodOptional<z.ZodString>;
+        gaps: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                "legacy-run-id-missing": "legacy-run-id-missing";
+                "mutation-revision-missing": "mutation-revision-missing";
+                "partial-git-provenance": "partial-git-provenance";
+                "git-session-stamp-missing": "git-session-stamp-missing";
+                "external-resource-unnamed": "external-resource-unnamed";
+                "produced-resource-unnamed": "produced-resource-unnamed";
+                "skill-suggestion-unattributable": "skill-suggestion-unattributable";
+                "malformed-source-record": "malformed-source-record";
+                "source-unreadable": "source-unreadable";
+                "git-revision-unavailable": "git-revision-unavailable";
+                "automation-history-unavailable": "automation-history-unavailable";
+                "session-history-unavailable": "session-history-unavailable";
+                "required-evidence-missing": "required-evidence-missing";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+
+declare type AgentRuntimeAutomationRunDetail = z.infer<typeof AgentRuntimeAutomationRunDetail>;
+
+/**
+ * The optional schema-validated terminal output contract a session may declare
+ * (issue #2234). `schema` is a bounded JSON object (a JSON Schema); `required`
+ * (default off) decides whether a text-only completion settles the turn -
+ * `true` holds every run to a submission, while the `"per-run"` literal defers
+ * the decision to each run's driver (a reused subagent session's assignment
+ * runs are stamped; its internal wake turns are not);
+ * `sessionTitle` (default off) adds the reserved `submit_final` field a turn
+ * uses to rename its own session; `whenToSubmit` is the one sentence telling the
+ * model when an OPTIONAL submission is worth making (ignored when `required`
+ * is `true` or `"per-run"`).
+ * The wire enforces the size caps and the credential-key tripwire; the herd
+ * kernel enforces the full acceptance policy (JSON-only, depth, non-local
+ * `$ref`).
+ *
+ * STRICT on purpose, which makes this schema a required stop for every new
+ * contract field: an unmirrored one is not merely absent on the wire, it fails
+ * the whole contract's parse, and the consumer that reads a stored session drops
+ * the contract entirely rather than reporting anything.
+ */
+declare const AgentRuntimeFinalOutputContract: z.ZodObject<{
+    schema: z.ZodType<{
+        [key: string]: JsonValue_5;
+    }, unknown, z.core.$ZodTypeInternals<{
+        [key: string]: JsonValue_5;
+    }, unknown>>;
+    required: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"per-run">]>>;
+    sessionTitle: z.ZodOptional<z.ZodBoolean>;
+    whenToSubmit: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+
+declare type AgentRuntimeFinalOutputContract = z.infer<typeof AgentRuntimeFinalOutputContract>;
+
+declare const AgentRuntimeModality: z.ZodEnum<{
+    text: "text";
+    image: "image";
+    audio: "audio";
+    video: "video";
+    pdf: "pdf";
+    embedding: "embedding";
+}>;
+
+declare type AgentRuntimeModality = z.infer<typeof AgentRuntimeModality>;
+
+/** Model pricing in USD per one million tokens. */
+declare const AgentRuntimeModelCost: z.ZodObject<{
+    input: z.ZodNumber;
+    output: z.ZodNumber;
+    cacheRead: z.ZodNumber;
+    cacheWrite: z.ZodNumber;
+}, z.core.$strict>;
+
+declare type AgentRuntimeModelCost = z.infer<typeof AgentRuntimeModelCost>;
+
+declare const AgentRuntimeModelFeatures: z.ZodObject<{
+    thinking: z.ZodBoolean;
+    vision: z.ZodBoolean;
+    toolUse: z.ZodBoolean;
+    streaming: z.ZodBoolean;
+    reasoning: z.ZodOptional<z.ZodBoolean>;
+    inputModalities: z.ZodArray<z.ZodEnum<{
+        text: "text";
+        image: "image";
+        audio: "audio";
+        video: "video";
+        pdf: "pdf";
+        embedding: "embedding";
+    }>>;
+    outputModalities: z.ZodArray<z.ZodEnum<{
+        text: "text";
+        image: "image";
+        audio: "audio";
+        video: "video";
+        pdf: "pdf";
+        embedding: "embedding";
+    }>>;
+    structuredOutput: z.ZodOptional<z.ZodBoolean>;
+    promptCaching: z.ZodOptional<z.ZodBoolean>;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+
+declare type AgentRuntimeModelFeatures = z.infer<typeof AgentRuntimeModelFeatures>;
+
+declare const AgentRuntimeModelScores: z.ZodObject<{
+    intelligence: z.ZodOptional<z.ZodObject<{
+        value: z.ZodNumber;
+    }, z.core.$strict>>;
+    coding: z.ZodOptional<z.ZodObject<{
+        value: z.ZodNumber;
+    }, z.core.$strict>>;
+    speedTps: z.ZodOptional<z.ZodObject<{
+        value: z.ZodNumber;
+    }, z.core.$strict>>;
+    categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: z.ZodNumber;
+    }, z.core.$strict>>>;
+    source: z.ZodOptional<z.ZodString>;
+    asOf: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+
+declare type AgentRuntimeModelScores = z.infer<typeof AgentRuntimeModelScores>;
+
+declare const AgentRuntimeModelTierId: z.ZodEnum<{
+    small: "small";
+    medium: "medium";
+    large: "large";
+    ultra: "ultra";
+}>;
+
+declare type AgentRuntimeModelTierId = z.infer<typeof AgentRuntimeModelTierId>;
+
+/**
+ * One product model tier (resolved through the provider tier tables), projected with the
+ * model the tier RESOLVES TO for this runtime right now. `resolved` is absent
+ * when nothing - pin or floor - is currently eligible; the preview is
+ * point-in-time (checked-strength, never minting), so surfaces re-fetch rather
+ * than cache it across auth changes.
+ */
+declare const AgentRuntimeModelTierInfo: z.ZodObject<{
+    id: z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+        ultra: "ultra";
+    }>;
+    displayName: z.ZodString;
+    description: z.ZodString;
+    resolved: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        modelId: z.ZodString;
+        modelReference: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+
+declare type AgentRuntimeModelTierInfo = z.infer<typeof AgentRuntimeModelTierInfo>;
+
+declare const AgentRuntimeSessionMode: z.ZodEnum<{
+    default: "default";
+    auto: "auto";
+    ask: "ask";
+    allow: "allow";
+}>;
+
+declare type AgentRuntimeSessionMode = z.infer<typeof AgentRuntimeSessionMode>;
+
+/** The judge's own certainty in its verdict - a tuning filter, never a weight applied for the reader. */
+declare const AgentRuntimeSessionOutcomeConfidence: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+}>;
+
+declare type AgentRuntimeSessionOutcomeConfidence = z.infer<typeof AgentRuntimeSessionOutcomeConfidence>;
+
+/**
+ * How a session's work is judged to have served the user (telemetry lane
+ * PR 5, `docs/telemetry-lane-pr5-contracts.md` §2.1).
+ *
+ * `"unclear"` is a FIRST-CLASS verdict, not an error code: a judge that cannot
+ * tell must say so rather than guess, and the share of `unclear` is itself a
+ * tuning metric for the rubric that produced it.
+ */
+declare const AgentRuntimeSessionOutcomeVerdict: z.ZodEnum<{
+    bad: "bad";
+    good: "good";
+    mixed: "mixed";
+    unclear: "unclear";
+}>;
+
+declare type AgentRuntimeSessionOutcomeVerdict = z.infer<typeof AgentRuntimeSessionOutcomeVerdict>;
+
+/**
+ * A session's live or last durable run state. `interrupted` and `cancelled` are
+ * distinct terminal states, not synonyms: INTERRUPTED means the turn was stopped
+ * and the session's detached work kept running; CANCELLED means the run and all
+ * of that work ended together. Records written before this split stored every
+ * user stop as `cancelled`, and are mapped forward on read.
+ */
+declare const AgentRuntimeSessionRunState: z.ZodEnum<{
+    interrupted: "interrupted";
+    cancelled: "cancelled";
+    completed: "completed";
+    failed: "failed";
+    running: "running";
+}>;
+
+declare type AgentRuntimeSessionRunState = z.infer<typeof AgentRuntimeSessionRunState>;
+
+/**
+ * One session-steward observation (hindsight): structured FACTS, never
+ * actions - appended to the session's log as a `session_steward` custom entry,
+ * from which summary state derives (`stewardTitle` / `stewardCommentary` /
+ * `stewardNextSteps` / `stewardCompactionSuggested`). Derivation is
+ * side-effect-free by contract. The compaction flag has two consumers:
+ * auto-compaction taken once at append time behind the
+ * `kayLoop.hindsight.stewardAutoCompact` flag, and - when auto-compact is
+ * off - the standing `stewardCompactionSuggested` summary field that backs
+ * the UI's "compact now" affordance. NOT itself a wire payload - it
+ * lives here as the ONE shared source of the summary's steward fields (the
+ * entry on disk, the backend fold, and the stored-state reader all validate
+ * against it); only the derived summary fields ever cross the wire.
+ */
+declare const AgentRuntimeSessionStewardEntry: z.ZodObject<{
+    titleChange: z.ZodNullable<z.ZodString>;
+    summaryAddition: z.ZodNullable<z.ZodString>;
+    nextSteps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    workHeadline: z.ZodOptional<z.ZodString>;
+    workHeadlineReview: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        labelKind: z.ZodEnum<{
+            purpose: "purpose";
+            result: "result";
+        }>;
+        text: z.ZodString;
+        faultProbability: z.ZodNullable<z.ZodNumber>;
+        accepted: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        attempt: z.ZodObject<{
+            outcome: z.ZodEnum<{
+                error: "error";
+                none: "none";
+                rejected: "rejected";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>>>;
+    workBlock: z.ZodOptional<z.ZodObject<{
+        firstToolResultEntryId: z.ZodString;
+        lastToolResultEntryId: z.ZodString;
+        toolResultEntryIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    goodCompactionOpportunity: z.ZodOptional<z.ZodBoolean>;
+    suggestedModelTier: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+        ultra: "ultra";
+    }>>>;
+    reviewedThroughEntryId: z.ZodOptional<z.ZodString>;
+    outcomeVerdict: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        verdict: z.ZodEnum<{
+            bad: "bad";
+            good: "good";
+            mixed: "mixed";
+            unclear: "unclear";
+        }>;
+        confidence: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        basis: z.ZodString;
+        correctionsObserved: z.ZodNumber;
+        retriesObserved: z.ZodNumber;
+        rubricVersion: z.ZodNumber;
+    }, z.core.$strict>>>;
+    deferredVerdicts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        subjectSessionId: z.ZodString;
+        verdict: z.ZodEnum<{
+            bad: "bad";
+            good: "good";
+            mixed: "mixed";
+            unclear: "unclear";
+        }>;
+        confidence: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        basis: z.ZodString;
+        rubricVersion: z.ZodNumber;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+
+declare type AgentRuntimeSessionStewardEntry = z.infer<typeof AgentRuntimeSessionStewardEntry>;
+
+/** One trailing-window spend view (mirrors `SpendWindowView`). */
+declare const AgentRuntimeSpendWindow: z.ZodObject<{
+    window: z.ZodEnum<{
+        trailing24h: "trailing24h";
+        trailing7d: "trailing7d";
+        trailing30d: "trailing30d";
+        trailing90d: "trailing90d";
+    }>;
+    measuredUsd: z.ZodNumber;
+    estimatedUsd: z.ZodNumber;
+    unknownTurns: z.ZodNumber;
+    tokens: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+    }, z.core.$strict>;
+    effectiveUsdPerMTok: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+
+declare type AgentRuntimeSpendWindow = z.infer<typeof AgentRuntimeSpendWindow>;
+
+declare const AgentRuntimeThinkingLevel: z.ZodEnum<{
+    max: "max";
+    off: "off";
+    minimal: "minimal";
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+}>;
+
+declare type AgentRuntimeThinkingLevel = z.infer<typeof AgentRuntimeThinkingLevel>;
+
 /** Final or partial result produced by a tool. */
 export declare interface AgentToolResult<T = JsonValue_2 | undefined> {
     /** Text or image content returned to the model. */
@@ -379,6 +1379,364 @@ declare const AuthServiceReference: z.ZodString;
 
 declare type AuthServiceReference = z.infer<typeof AuthServiceReference>;
 
+/**
+ * One session run a getRun read reports. `shared: true` means that session
+ * run had more than one admitted input at that point; it does not choose a
+ * winner. The embedded session summary reuses the wire's own display shape.
+ */
+declare const AutomationActivityItem: z.ZodObject<{
+    sessionId: z.ZodString;
+    sessionRunId: z.ZodString;
+    kind: z.ZodEnum<{
+        direct: "direct";
+        child: "child";
+    }>;
+    shared: z.ZodBoolean;
+    session: z.ZodObject<{
+        sessionId: z.ZodString;
+        agentId: z.ZodOptional<z.ZodString>;
+        parentSessionId: z.ZodNullable<z.ZodString>;
+        predecessorSessionId: z.ZodNullable<z.ZodString>;
+        openedBySessionId: z.ZodNullable<z.ZodString>;
+        rootSessionId: z.ZodString;
+        spawnDepth: z.ZodNumber;
+        cwd: z.ZodOptional<z.ZodString>;
+        displayTitle: z.ZodOptional<z.ZodString>;
+        userTitle: z.ZodOptional<z.ZodString>;
+        stewardTitle: z.ZodOptional<z.ZodString>;
+        stewardCommentary: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        stewardNextSteps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        stewardCompactionSuggested: z.ZodOptional<z.ZodLiteral<true>>;
+        stewardSuggestedModelTier: z.ZodOptional<z.ZodEnum<{
+            small: "small";
+            medium: "medium";
+            large: "large";
+            ultra: "ultra";
+        }>>;
+        provider: z.ZodOptional<z.ZodString>;
+        modelReference: z.ZodOptional<z.ZodString>;
+        modelAccountName: z.ZodOptional<z.ZodString>;
+        modelSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"specific">;
+            modelReference: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"tier">;
+            tierId: z.ZodEnum<{
+                small: "small";
+                medium: "medium";
+                large: "large";
+                ultra: "ultra";
+            }>;
+            provider: z.ZodOptional<z.ZodString>;
+            constraints: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodOptional<z.ZodString>;
+                vendor: z.ZodOptional<z.ZodString>;
+                notVendor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"model">;
+            model: z.ZodString;
+            constraints: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodOptional<z.ZodString>;
+                vendor: z.ZodOptional<z.ZodString>;
+                notVendor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">>;
+        activeToolNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            auto: "auto";
+            ask: "ask";
+            allow: "allow";
+        }>>;
+        thinkingLevel: z.ZodOptional<z.ZodEnum<{
+            max: "max";
+            off: "off";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
+        processingSpeed: z.ZodOptional<z.ZodEnum<{
+            standard: "standard";
+            fast: "fast";
+        }>>;
+        artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            uri: z.ZodString;
+            kind: z.ZodString;
+            name: z.ZodString;
+            title: z.ZodString;
+            updatedAtMs: z.ZodNumber;
+            mimeType: z.ZodOptional<z.ZodString>;
+            sizeBytes: z.ZodOptional<z.ZodNumber>;
+            committedVersionState: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                state: z.ZodLiteral<"draft">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"clean">;
+                committedVersion: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"edited">;
+                committedVersion: z.ZodNumber;
+            }, z.core.$strict>], "state">>;
+        }, z.core.$strict>>>;
+        running: z.ZodBoolean;
+        runState: z.ZodOptional<z.ZodEnum<{
+            interrupted: "interrupted";
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+            running: "running";
+        }>>;
+        origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"user">;
+            surface: z.ZodOptional<z.ZodString>;
+            onboardingAttemptId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"subagent">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"system">;
+            surface: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"followup">;
+            parentSessionId: z.ZodString;
+            surface: z.ZodString;
+            forkedAtEntryId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "kind">;
+        createdAt: z.ZodOptional<z.ZodISODateTime>;
+        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+        runStartedAt: z.ZodOptional<z.ZodNumber>;
+        runSettledAt: z.ZodOptional<z.ZodNumber>;
+        detachedWorkStartedAt: z.ZodOptional<z.ZodNumber>;
+        state: z.ZodOptional<z.ZodObject<{
+            value: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                needs_you: "needs_you";
+                waiting: "waiting";
+                idle: "idle";
+            }>;
+            since: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        lastSeenAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        archivedAtMs: z.ZodOptional<z.ZodNumber>;
+        pinnedAtMs: z.ZodOptional<z.ZodNumber>;
+        deletedAtMs: z.ZodOptional<z.ZodNumber>;
+        remotePeerId: z.ZodOptional<z.ZodString>;
+        provenance: z.ZodOptional<z.ZodObject<{
+            relationships: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"child-of">;
+                sessionId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"forked-from">;
+                sessionId: z.ZodString;
+                atEntryId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "kind">>;
+            createdBy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"human">;
+                surface: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"agent">;
+                sessionId: z.ZodString;
+                tool: z.ZodString;
+                runId: z.ZodOptional<z.ZodString>;
+                toolCallId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"plugin">;
+                pluginId: z.ZodString;
+                door: z.ZodEnum<{
+                    "sessions.create": "sessions.create";
+                    "sessions.run": "sessions.run";
+                    "hindsight.runFollowup": "hindsight.runFollowup";
+                    "agents.run": "agents.run";
+                }>;
+                callerSessionId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"trigger">;
+                automationId: z.ZodString;
+                runId: z.ZodOptional<z.ZodString>;
+                bindingName: z.ZodString;
+                triggerKind: z.ZodEnum<{
+                    time: "time";
+                    cron: "cron";
+                    occurrence: "occurrence";
+                    "uri-change": "uri-change";
+                    "plugin-event": "plugin-event";
+                    manual: "manual";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"daemon">;
+                capability: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            definedBy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                layer: z.ZodLiteral<"plugin">;
+                pluginId: z.ZodString;
+                capability: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                layer: z.ZodLiteral<"host">;
+                capability: z.ZodString;
+            }, z.core.$strict>], "layer">;
+            intent: z.ZodEnum<{
+                interactive: "interactive";
+                headless: "headless";
+            }>;
+            causedByEvent: z.ZodOptional<z.ZodObject<{
+                handler: z.ZodString;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    "session-event": "session-event";
+                    backfill: "backfill";
+                }>>;
+                event: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        "turn-settled": "turn-settled";
+                        "phase-shift": "phase-shift";
+                        "human-message": "human-message";
+                        "assistant-message": "assistant-message";
+                        "ui-action": "ui-action";
+                    }>;
+                    entryId: z.ZodString;
+                    runId: z.ZodOptional<z.ZodString>;
+                    throughEntryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>;
+                dedupeKey: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        projectId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+
+declare type AutomationActivityItem = z.infer<typeof AutomationActivityItem>;
+
+/**
+ * One Git-backed artifact TARGET a getRun read reports: the thing produced or
+ * changed, not one change to it. A run that edited a skill twice reports one
+ * row with `revisionCount: 2`, because two rows differing only by sha read as
+ * duplicates. The grouping key is (artifact, authoring session), so two
+ * sessions that touched the same uri in one run stay two rows.
+ *
+ * `sessionId` is the authoring session; an `app:artifact:output` URI is only
+ * unique within it. `offBranch` marks a revision whose source tool-result left the
+ * session branch; the change is still attributable because the external side
+ * effect landed. `shared` means the authoring session run had more than one
+ * admitted input at that point. Both are true when ANY revision in the group
+ * is.
+ */
+declare const AutomationArtifactItem: z.ZodObject<{
+    uri: z.ZodString;
+    moduleId: z.ZodString;
+    sessionId: z.ZodString;
+    action: z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+        deleted: "deleted";
+    }>;
+    revision: z.ZodString;
+    revisionCount: z.ZodNumber;
+    offBranch: z.ZodBoolean;
+    shared: z.ZodBoolean;
+}, z.core.$strict>;
+
+declare type AutomationArtifactItem = z.infer<typeof AutomationArtifactItem>;
+
+/**
+ * One thing a run created off this machine - today a GitHub pull request its
+ * session opened with `gh pr create`. A sibling of `AutomationArtifactItem`
+ * rather than a widening of it: that type's non-empty `revision` and closed
+ * `moduleId` are guarantees git-backed consumers rely on, and an external
+ * resource has neither. It is not revision-backed, not addressed by a Bonsai uri
+ * module, and not a thing this machine can re-read.
+ *
+ * `url` is the canonical resource URL the transcript itself printed, which is
+ * also the entity's own identity. `sessionId` is the session whose run created
+ * it, and `shared` means that session run had more than one admitted input at
+ * that point - the same meaning both other run-detail lists give the word.
+ *
+ * There is deliberately NO `offBranch` here, unlike an artifact row. Branch
+ * membership is not consulted when this fact is projected and could not be
+ * honest if it were: an abandoned transcript branch does not un-open a pull
+ * request. A field that can only ever be
+ * `false` is a guarantee nothing is making.
+ */
+declare const AutomationExternalResourceItem: z.ZodObject<{
+    url: z.ZodString;
+    kind: z.ZodEnum<{
+        "github-pr": "github-pr";
+    }>;
+    sessionId: z.ZodString;
+    shared: z.ZodBoolean;
+}, z.core.$strict>;
+
+declare type AutomationExternalResourceItem = z.infer<typeof AutomationExternalResourceItem>;
+
+/**
+ * One URI a run produced: every URI its successful `write` and `edit` calls
+ * changed, every URI a tool declared it created or updated (the
+ * `producedResources` tool-result contract in `@herd/uri`), and every row
+ * `artifacts` and `externalResources` report, deduplicated by exact URI
+ * string. A session-scoped URI (`output://`) names a different resource in
+ * each session, so it is one row per session.
+ *
+ * `uri` is a `scheme://` URI, an absolute local file path, or the canonical
+ * https URL of an external resource. `sessionId` is the session that produced
+ * it; when several did, the first in activity order that carries the winning
+ * certainty and action. Stated action evidence wins over inferred verb
+ * evidence; within the same certainty, action precedence decides.
+ * `offBranch` and `shared` mean what they mean on an artifact row, and are
+ * true when any contribution is.
+ */
+declare const AutomationProducedResourceItem: z.ZodObject<{
+    uri: z.ZodString;
+    action: z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+        deleted: "deleted";
+    }>;
+    sessionId: z.ZodString;
+    revision: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strict>>;
+    offBranch: z.ZodBoolean;
+    shared: z.ZodBoolean;
+}, z.core.$strict>;
+
+declare type AutomationProducedResourceItem = z.infer<typeof AutomationProducedResourceItem>;
+
+/**
+ * How much of one run's work a read could establish. `partial` carries the
+ * gaps that make it so; each gap bears on this run only. The daemon reads a
+ * run's transcripts on demand, so there is no settling state to report.
+ */
+declare const AutomationRunCoverage: z.ZodObject<{
+    state: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+    asOfMs: z.ZodNumber;
+    stamp: z.ZodOptional<z.ZodString>;
+    gaps: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            "legacy-run-id-missing": "legacy-run-id-missing";
+            "mutation-revision-missing": "mutation-revision-missing";
+            "partial-git-provenance": "partial-git-provenance";
+            "git-session-stamp-missing": "git-session-stamp-missing";
+            "external-resource-unnamed": "external-resource-unnamed";
+            "produced-resource-unnamed": "produced-resource-unnamed";
+            "skill-suggestion-unattributable": "skill-suggestion-unattributable";
+            "malformed-source-record": "malformed-source-record";
+            "source-unreadable": "source-unreadable";
+            "git-revision-unavailable": "git-revision-unavailable";
+            "automation-history-unavailable": "automation-history-unavailable";
+            "session-history-unavailable": "session-history-unavailable";
+            "required-evidence-missing": "required-evidence-missing";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+
+declare type AutomationRunCoverage = z.infer<typeof AutomationRunCoverage>;
+
 declare interface Availability {
     readonly available: boolean;
     readonly reason?: string;
@@ -954,6 +2312,9 @@ export declare function createKayPluginLog(write: (line: KayPluginLogLine) => vo
 
 export declare function createUnavailablePluginEndpointCaller(message: string): PluginEndpointCaller;
 
+/** A refusal handle for hosts that have not composed plugin worker execution. */
+export declare function createUnavailablePluginWorkers(): KayPluginWorkers;
+
 /**
  * A `KayAppSealing` that answers `unavailable` to every call: what a host with no vault binds, so
  * `app.sealing` stays present on every host.
@@ -1338,6 +2699,21 @@ declare class EncodeBuilder<Type extends TSchema, Encoded extends unknown, Decod
     Encode(callback: TEncodeCallback<Encoded, Decoded>): TCodec<Type, Decoded>;
 }
 
+export declare const EndpointContribution: z.ZodObject<{
+    localId: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    requestSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<authoringCommonSchemas.JsonValue, unknown, z.core.$ZodTypeInternals<authoringCommonSchemas.JsonValue, unknown>>>>;
+    responseSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<authoringCommonSchemas.JsonValue, unknown, z.core.$ZodTypeInternals<authoringCommonSchemas.JsonValue, unknown>>>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        service: z.ZodString;
+        schemes: z.ZodArray<z.ZodString>;
+        purpose: z.ZodString;
+    }, z.core.$strict>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+
+export declare type EndpointContribution = z.infer<typeof EndpointContribution>;
+
 declare interface EntryBase {
     id: string;
     parentId: string | null;
@@ -2183,6 +3559,12 @@ declare type JsonValue_4 = JsonPrimitive | {
     readonly [key: string]: JsonValue_4;
 } | readonly JsonValue_4[];
 
+declare type JsonValue_5 = string | number | boolean | null | JsonValue_5[] | {
+    [key: string]: JsonValue_5;
+};
+
+declare const JsonValue_5: z.ZodType<JsonValue_5>;
+
 /**
  * Every condition kind an automation can be created with, as runtime data.
  *
@@ -2915,11 +4297,48 @@ declare const KAY_PLUGIN_PROTOCOL_VERSION: "kay.plugin.v1";
  * 0.53.0 adds declared working-content layouts, family-root authority, draft projection discovery
  * and session-bound page references. Older customized Whiteboard copies must accept the plugin
  * update before using these interfaces.
+ *
+ * 0.54.0 adds named UI host grants for shared configuration/auth/account reads, retained connection
+ * progress/dismissal and support. Built-in-only page capability scopes are removed; executable
+ * pages declare capabilities on apps[].
+ *
+ * 0.54.1 adds manifest-declared plugin workers on both backend targets and exposes the canonical
+ * transcript placement and answer-stretch rules through the SDK.
  */
-declare const KAY_PLUGIN_SDK_VERSION: "0.53.0";
+declare const KAY_PLUGIN_SDK_VERSION: "0.54.1";
 
 declare const KAY_PLUGIN_TARGET_NAMES: readonly ["kay.agent", "kay.app", "kay.ui"];
 
+/**
+ * One process the plugin asks the host to run.
+ *
+ * `argvClass` is required and is NOT decoration: it names the class of argument vector this
+ * invocation belongs to, and it must match a class the plugin declared alongside `command` in its
+ * manifest. Declaring a command alone would authorize `git log` and `git push --force` identically;
+ * the class is what a user can be shown and asked to consent to. The host judges the real `args`
+ * against the named class and refuses with `argv-outside-class` when they do not belong to it.
+ */
+declare interface KayAgentProcessRunRequest {
+    readonly command: string;
+    readonly argvClass: string;
+    readonly args: readonly string[];
+    /** Abort the run; the host kills the DIRECT child and rejects - a forked descendant may outlive it (#6153). */
+    readonly signal?: AbortSignal;
+}
+
+/**
+ * A finished run. `stdout`/`stderr` are decoded text, and the host CAPS them - a truncation flag is
+ * set rather than the output silently ending, so a plugin parsing the stream can tell "the command
+ * printed this" apart from "the command printed more than we kept".
+ */
+declare interface KayAgentProcessRunResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly stdoutTruncated?: boolean;
+    readonly stderrTruncated?: boolean;
+}
+
 declare interface KayAgentWhiteboardCreateInput {
     readonly name: string;
     readonly title: string;
@@ -3334,13 +4753,7 @@ export declare interface KayAppAgentDefinitionConfig {
 }
 
 /** A plugin-authored definition's structured-output contract (the wire's final-output shape). */
-export declare interface KayAppAgentDefinitionFinalOutput {
-    /** JSON Schema for the structured value a matching turn submits. */
-    readonly schema: JsonSchema;
-    readonly required?: boolean | "per-run";
-    readonly sessionTitle?: boolean;
-    readonly whenToSubmit?: string;
-}
+export declare type KayAppAgentDefinitionFinalOutput = ReadonlyContract<AgentRuntimeFinalOutputContract>;
 
 /**
  * An opaque handle to one definition THIS plugin registered. `define` returns it; `sessions.run`
@@ -3438,16 +4851,7 @@ export declare interface KayAppAgents {
     }): Promise<KayAppSessionRunOutcome>;
 }
 
-export declare interface KayAppArtifact {
-    readonly uri: string;
-    readonly kind: string;
-    readonly name: string;
-    readonly title: string;
-    readonly updatedAtMs: number;
-    readonly mimeType?: string | undefined;
-    readonly sizeBytes?: number | undefined;
-    readonly committedVersionState?: KayAppArtifactCommittedVersionState | undefined;
-}
+export declare type KayAppArtifact = ReadonlyContract<AgentRuntimeArtifact>;
 
 export declare type KayAppArtifactCommittedVersionState = {
     readonly state: "draft";
@@ -3479,6 +4883,16 @@ export declare type KayAppArtifactOutputFile = {
 };
 
 export declare interface KayAppArtifactOutputs extends Omit<KayAppKnowledgeSource, "watchRoots"> {
+    /**
+     * One page of canonical output URIs across every chat or, with `sessionId`,
+     * only that chat's outputs. A cursor continues the enumeration it came from.
+     */
+    enumerate(options: {
+        readonly cursor?: JsonValue;
+        readonly limit: number;
+        readonly signal: AbortSignal;
+        readonly sessionId?: string;
+    }): ReturnType<KayAppKnowledgeSource["enumerate"]>;
     subscribe(listener: (change: ArtifactOutputChange) => void): () => void;
     /**
      * The exact bytes of one canonical `output://<session>/<name>` file, at most `maxBytes`
@@ -3494,6 +4908,13 @@ export declare interface KayAppArtifactOutputs extends Omit<KayAppKnowledgeSourc
 export declare interface KayAppArtifacts {
     /** Activation-only request for the public artifacts.read {kind: output} capability. */
     outputs(): KayAppArtifactOutputs;
+    /**
+     * Private API: only plugins Bonsai ships; refused for any other. The absolute path of the file
+     * an address names as `sessionId`'s agent would see it (`output://`, `file://` and the other
+     * file-backed schemes), or `undefined` when it names no readable file. Checked against
+     * `artifacts.resolve-file`; a refused call rejects.
+     */
+    resolveFile?(sessionId: string, uri: string): Promise<string | undefined>;
 }
 
 /** A persisted assistant message, published without waiting for its subscribers. */
@@ -3548,44 +4969,15 @@ export declare interface KayAppAuth {
  * run had more than one admitted input at that point; it does not choose a
  * winner.
  */
-export declare interface KayAppAutomationActivityItem {
-    readonly sessionId: string;
-    readonly sessionRunId: string;
-    /**
-     * `direct`: the automation run's own input admitted this session run.
-     * `child`: this session was created by a session run the automation run
-     * started, and its first run is reported.
-     */
-    readonly kind: "direct" | "child";
-    readonly shared: boolean;
+export declare type KayAppAutomationActivityItem = Omit<Readonly<AutomationActivityItem>, "session"> & {
     readonly session: KayAppSessionSummary;
-}
+};
 
 /**
  * One Git-backed artifact TARGET a run-detail read reports (R3 populated):
  * the thing produced or changed, with its revisions collapsed behind it.
  */
-export declare interface KayAppAutomationArtifactItem {
-    readonly uri: string;
-    readonly moduleId: string;
-    /**
-     * The authoring session. Required on the wire, and load-bearing rather than
-     * decorative: it is the session an `app:artifact:output` uri must be
-     * resolved against to open at all.
-     */
-    readonly sessionId: string;
-    /** Collapsed by precedence: `deleted` > `created` > `updated`. */
-    readonly action: "created" | "updated" | "deleted";
-    /**
-     * One real revision of the group, carrying the action above. Not
-     * necessarily the newest revision of the target.
-     */
-    readonly revision: string;
-    /** How many revisions this row collapsed. Always at least 1. */
-    readonly revisionCount: number;
-    readonly offBranch: boolean;
-    readonly shared: boolean;
-}
+export declare type KayAppAutomationArtifactItem = Readonly<AutomationArtifactItem>;
 
 export declare interface KayAppAutomationBinding {
     readonly id: string;
@@ -3754,17 +5146,9 @@ export declare type KayAppAutomationEffectInput = {
  * abandoned transcript branch does not un-open a pull request, so branch
  * membership is never consulted for these facts.
  */
-export declare interface KayAppAutomationExternalResourceItem {
-    /** The canonical resource URL the session's own transcript printed. */
-    readonly url: string;
-    readonly kind: "github-pr";
-    /** The session whose run created it. */
-    readonly sessionId: string;
-    /** That session run had more than one admitted input at the time. */
-    readonly shared: boolean;
-}
+export declare type KayAppAutomationExternalResourceItem = Readonly<AutomationExternalResourceItem>;
 
-export declare type KayAppAutomationFactSource = "run-settled" | "tool-used" | "tool-failed";
+export declare type KayAppAutomationFactSource = AgentRuntimeAutomationFactSource;
 
 export declare type KayAppAutomationMatch = {
     readonly kind: "plugin-event";
@@ -3844,20 +5228,7 @@ export declare interface KayAppAutomationPluginEventCondition {
  * resource's canonical https URL. Stated action evidence wins over inferred
  * verb evidence; within the same certainty, action precedence decides.
  */
-export declare interface KayAppAutomationProducedResourceItem {
-    readonly uri: string;
-    /** Stated evidence beats inferred evidence; within one certainty, `deleted` > `created` > `updated`. Only an artifact receipt reports `deleted`. */
-    readonly action: "created" | "updated" | "deleted";
-    /** The first activity-ordered session carrying the winning certainty and action; for a session-scoped URI, the session it resolves against. */
-    readonly sessionId: string;
-    /** The last revision recorded for the winning certainty/action, or the last revision of the highest-ranked revision-bearing contribution (stated before inferred, then action precedence), and how many distinct revisions there were; ordered by activity, not time. */
-    readonly revision?: {
-        readonly id: string;
-        readonly count: number;
-    } | undefined;
-    readonly offBranch: boolean;
-    readonly shared: boolean;
-}
+export declare type KayAppAutomationProducedResourceItem = ReadonlyContract<AutomationProducedResourceItem>;
 
 /** Every URI one run produced, served whole: at most 1,000 rows, `truncated` when there were more. */
 export declare interface KayAppAutomationProducedResources {
@@ -3880,37 +5251,16 @@ export declare interface KayAppAutomationRun {
 }
 
 /** Projection coverage state: how current the read model is for this answer. */
-export declare interface KayAppAutomationRunCoverage {
-    readonly state: "complete" | "partial" | "rebuilding";
-    readonly asOfMs: number;
-    /**
-     * An opaque token over ONE materialized root's product-visible state;
-     * present only when this answer describes exactly one materialized root,
-     * absent otherwise (synthesized, `rebuilding`, or an aggregate over more
-     * than one root - a stamp is inherently single-root). Compare for
-     * equality only - never parse, order, or decompose it. Equal means that
-     * root has not moved; a missing stamp means unknown, so treat it as moved.
-     */
-    readonly stamp?: string | undefined;
-    readonly gaps: readonly KayAppProvenanceGapSummary[];
-}
+export declare type KayAppAutomationRunCoverage = Omit<ReadonlyContract<AutomationRunCoverage>, "state"> & {
+    readonly state: AutomationRunCoverage["state"] | "rebuilding";
+};
 
 /** One automation run's provenance detail (RFC Release 2). */
-export declare interface KayAppAutomationRunDetail {
+export declare type KayAppAutomationRunDetail = ReadonlyContract<Omit<AgentRuntimeAutomationRunDetail, "run" | "activity" | "coverage">> & {
     readonly run: KayAppAutomationRun;
     readonly activity: KayAppProvenancePage<KayAppAutomationActivityItem>;
-    readonly artifacts: KayAppProvenancePage<KayAppAutomationArtifactItem>;
-    /**
-     * What the run created off this machine. Its own page because it pages on
-     * its own cursor; one section with the artifacts wherever it is rendered,
-     * because a pull request is something the run produced.
-     */
-    readonly externalResources: KayAppProvenancePage<KayAppAutomationExternalResourceItem>;
-    /** The one list of everything the run produced; it includes every row of the two lists above. */
-    readonly producedResources: KayAppAutomationProducedResources;
-    readonly suggestions: KayAppProvenancePage<KayAppAutomationSuggestionItem>;
     readonly coverage: KayAppAutomationRunCoverage;
-}
+};
 
 export declare interface KayAppAutomationRunDetailOptions {
     readonly activityLimit?: number | undefined;
@@ -4915,27 +6265,10 @@ export declare type KayAppModelCompleteOutcome = {
 };
 
 /** Per-million-token model prices projected by the host. */
-export declare interface KayAppModelCost {
-    readonly input: number;
-    readonly output: number;
-    readonly cacheRead: number;
-    readonly cacheWrite: number;
-}
+export declare type KayAppModelCost = Readonly<AgentRuntimeModelCost>;
 
 /** Model capabilities safe for plugin policy and presentation. */
-export declare interface KayAppModelFeatures {
-    readonly thinking: boolean;
-    readonly vision: boolean;
-    readonly toolUse: boolean;
-    readonly streaming: boolean;
-    readonly reasoning?: boolean;
-    readonly inputModalities: readonly KayAppModelModality[];
-    readonly outputModalities: readonly KayAppModelModality[];
-    readonly structuredOutput?: boolean;
-    readonly promptCaching?: boolean;
-    readonly contextWindow?: number;
-    readonly maxOutputTokens?: number;
-}
+export declare type KayAppModelFeatures = ReadonlyContract<AgentRuntimeModelFeatures>;
 
 /** The plugin-safe projection of one model in Bonsai's live model catalog. */
 export declare interface KayAppModelInfo {
@@ -4966,7 +6299,7 @@ export declare interface KayAppModelInfo {
 }
 
 /** Input or output modality advertised by a model. */
-export declare type KayAppModelModality = "text" | "image" | "audio" | "video" | "pdf" | "embedding";
+export declare type KayAppModelModality = AgentRuntimeModality;
 
 /** Safe model catalog plus an optional, consented direct-completion broker. */
 export declare interface KayAppModels {
@@ -4998,14 +6331,7 @@ export declare interface KayAppModelScore {
 }
 
 /** Optional host-curated scores and their provenance. */
-export declare interface KayAppModelScores {
-    readonly intelligence?: KayAppModelScore;
-    readonly coding?: KayAppModelScore;
-    readonly speedTps?: KayAppModelScore;
-    readonly categories?: Readonly<Record<string, KayAppModelScore>>;
-    readonly source?: string;
-    readonly asOf?: string;
-}
+export declare type KayAppModelScores = ReadonlyContract<AgentRuntimeModelScores>;
 
 export declare type KayAppModelSelection = {
     readonly kind: "specific";
@@ -5132,7 +6458,7 @@ export declare interface KayAppModelSelectionSessionFacts {
 }
 
 /** Bonsai's canonical task-difficulty tier vocabulary at the plugin boundary. */
-export declare type KayAppModelTierId = "small" | "medium" | "large" | "ultra";
+export declare type KayAppModelTierId = AgentRuntimeModelTierId;
 
 /**
  * The plugin-safe projection of one product model tier (small/medium/large/ultra -
@@ -5142,17 +6468,7 @@ export declare type KayAppModelTierId = "small" | "medium" | "large" | "ultra";
  * something derivable from the model alone (the same model can be curated onto two
  * different tiers), so `listTiers()` is the only seam a plugin reads it through.
  */
-export declare interface KayAppModelTierInfo {
-    readonly id: KayAppModelTierId;
-    readonly displayName: string;
-    readonly description: string;
-    readonly resolved?: {
-        readonly provider: string;
-        readonly modelId: string;
-        readonly modelReference: string;
-        readonly displayName?: string;
-    };
-}
+export declare type KayAppModelTierInfo = ReadonlyContract<AgentRuntimeModelTierInfo>;
 
 export declare type KayAppOpenOutcome = {
     readonly status: "opened";
@@ -5198,6 +6514,13 @@ export declare interface KayAppPaths {
      * empty directory rather than an error.
      */
     readonly sessionsRoot?: string;
+    /**
+     * Absolute path to the folder holding the scratch working folders of chats started without a
+     * folder of their own (`<chatsRoot>/<id>`). Files written there belong to that one chat. Ask for
+     * this rather than deriving it: Desktop keeps it under the app's user-data root, not beside
+     * {@link sessionsRoot}. Absent when the host composed none.
+     */
+    readonly chatsRoot?: string;
     /**
      * Absolute path to Bonsai's local telemetry directory. The live telemetry lane itself is a
      * Postgres table (`telemetry.usage_events`), not anything under this path; it is never a
@@ -5337,6 +6660,11 @@ export declare interface KayAppPluginApi {
      * which blocks the daemon; see {@link KayAppRepos}.
      */
     readonly repos: KayAppRepos;
+    /**
+     * Private API: only plugins Bonsai ships; refused for any other. Runs a program the host bound
+     * for this plugin; see {@link KayAppProcess}. Absent when the host composed no program bindings.
+     */
+    readonly process?: KayAppProcess;
     /**
      * File I/O in user folders (stat, read, list, walk, realpath, write, mkdir, rename), run by the
      * host on its own worker threads under a deadline and answered as a typed result. Always present
@@ -5344,6 +6672,8 @@ export declare interface KayAppPluginApi {
      * daemon; see {@link KayAppUserFiles}.
      */
     readonly userFiles: KayAppUserFiles;
+    /** Always present; only modules declared by this plugin may run. SDK 0.54.1. */
+    readonly workers: KayPluginWorkers;
     /**
      * Read/arrange access to the live desktop workspace. Present whenever the host has a workspace
      * (a headless daemon may not); absence is a host fact, never a grant signal. Reading the snapshot
@@ -5601,18 +6931,31 @@ export declare interface KayAppPollResult<Cursor extends JsonValue> {
     readonly summary?: string;
 }
 
+/**
+ * Private API: only plugins Bonsai ships; refused for any other. Run a program the host bound
+ * for this plugin, the way {@link import("../kay-agent/index.ts").KayAgentProcess} does for an
+ * agent tool: the plugin names a command and an argument class, the host owns the executable,
+ * which arguments belong to the class, the time limit, the output cap, the working directory and
+ * the environment. Each run is checked against `process.run` and then the exact
+ * `process.spawn {command, argvClass}` claim; a refusal rejects with `KayAgentCapabilityError`,
+ * a timeout resolves with exit code 124.
+ */
+export declare interface KayAppProcess {
+    run(request: KayAppProcessRunRequest): Promise<KayAppProcessRunResult>;
+}
+
 export declare type KayAppProcessingSpeed = "standard" | "fast";
 
+export declare type KayAppProcessRunRequest = KayAgentProcessRunRequest;
+
+export declare type KayAppProcessRunResult = KayAgentProcessRunResult;
+
 /**
  * A gap reason on the run-detail wire: something about the run's work the
  * daemon could not establish from its session transcripts. The vocabulary is
  * closed; a daemon may emit only some of these codes.
  */
-export declare type KayAppProvenanceGapCode = "legacy-run-id-missing" | "mutation-revision-missing" | "partial-git-provenance" | "git-session-stamp-missing"
-/** A run created something off this machine that the transcript cannot name. */
-| "external-resource-unnamed"
-/** A run's write or edit succeeded and the transcript cannot name the URI it changed. */
-| "produced-resource-unnamed" | "skill-suggestion-unattributable" | "malformed-source-record" | "source-unreadable" | "git-revision-unavailable" | "automation-history-unavailable" | "session-history-unavailable" | "required-evidence-missing";
+export declare type KayAppProvenanceGapCode = ProvenanceGapCode;
 
 /** One gap, with enum-specific bounded detail; never a raw payload. */
 export declare interface KayAppProvenanceGapSummary {
@@ -5621,12 +6964,9 @@ export declare interface KayAppProvenanceGapSummary {
 }
 
 /** One bounded, coverage-explicit page of run-detail items. */
-export declare interface KayAppProvenancePage<T> {
-    readonly items: readonly T[];
-    readonly totalCount: number;
+export declare type KayAppProvenancePage<T> = Omit<ProvenancePage<T>, "nextCursor"> & {
     readonly nextCursor?: string | undefined;
-    readonly truncated: boolean;
-}
+};
 
 /** Options for an app-scoped URI module registration. Only `app` scope exists at this tier. */
 export declare interface KayAppRegisterUriModuleOptions {
@@ -5799,8 +7139,7 @@ export declare interface KayAppRunSummary {
 
 /**
  * The session provenance vocabulary, as the plugin protocol declares it. These used to be spelled
- * out here because the canonical schemas lived in `@bonsai/agent-runtime-protocol`, which this
- * package may not import; they now live in `@bonsai/plugin-protocol` (so artifact writers and the
+ * out here when the canonical schemas lived in `@bonsai/agent-runtime-protocol`; they now live in `@bonsai/plugin-protocol` (so artifact writers and the
  * daemon share one shape), and a mirror here would be exactly the second declaration the
  * placement law forbids. Each name is kept as an alias so existing plugin code keeps compiling.
  */
@@ -5850,33 +7189,7 @@ export declare interface KayAppSessionAgentDefinition {
  * optional field follows one rule: OMITTED says nothing and leaves the standing value alone, while
  * an explicit value replaces it (`[]` withdraws the next steps, `false` clears a compaction offer).
  */
-export declare interface KayAppSessionAnnotation {
-    readonly titleChange: string | null;
-    readonly summaryAddition: string | null;
-    readonly nextSteps?: readonly string[] | undefined;
-    /** A one-line label for the closed work block {@link workBlock} names. */
-    readonly workHeadline?: string;
-    readonly workHeadlineReview?: readonly ({
-        readonly labelKind: "result" | "purpose";
-        readonly text: string;
-        readonly faultProbability: number | null;
-        readonly accepted: boolean;
-        readonly reason?: string;
-    } | {
-        readonly attempt: {
-            readonly outcome: "none" | "rejected" | "error";
-        };
-    })[];
-    readonly workBlock?: WorkBlockCoverage;
-    readonly goodCompactionOpportunity?: boolean;
-    /** The last entry the annotation reviewed: the transcript marker's anchor. */
-    readonly reviewedThroughEntryId?: string;
-    /** A tier the remaining work suits better, or null when the current one still fits. */
-    readonly suggestedModelTier?: KayAppModelTierId | null;
-    readonly outcomeVerdict?: KayAppSessionOutcomeVerdict | null;
-    /** At most three; a verdict naming the annotated session itself is dropped. */
-    readonly deferredVerdicts?: readonly KayAppSessionDeferredVerdict[];
-}
+export declare type KayAppSessionAnnotation = ReadonlyContract<AgentRuntimeSessionStewardEntry>;
 
 /**
  * The generic session-event run door's own cause detail (G1, 2026-09; widened G5, 2026-09).
@@ -5954,12 +7267,7 @@ export declare interface KayAppSessionCostModelBreakdown {
 }
 
 /** Token counts across a set of model calls. */
-export declare interface KayAppSessionCostTokens {
-    readonly input: number;
-    readonly output: number;
-    readonly cacheRead: number;
-    readonly cacheWrite: number;
-}
+export declare type KayAppSessionCostTokens = Readonly<AgentRuntimeSpendWindow["tokens"]>;
 
 export declare type KayAppSessionCreator = SessionCreator;
 
@@ -6174,7 +7482,7 @@ export declare type KayAppSessionListRequest = {
     readonly sessionIds: readonly string[];
 };
 
-export declare type KayAppSessionMode = "default" | "ask" | "allow" | "auto";
+export declare type KayAppSessionMode = AgentRuntimeSessionMode;
 
 export declare type KayAppSessionOrigin = {
     readonly kind: "user";
@@ -6265,6 +7573,18 @@ export declare type KayAppSessionPageItem = (Omit<Extract<TranscriptPageItem, {
     readonly unreadable: unknown;
 }>;
 
+/** One write for {@link KayAppSessions.assignProject}. */
+export declare interface KayAppSessionProjectAssignment {
+    readonly sessionId: string;
+    /**
+     * The project the session must still hold for the write to land: a project id, `null` for "no
+     * project" chosen on purpose, or absent for a session whose project was never decided.
+     */
+    readonly expectedProjectId?: string | null;
+    /** The project to set; `null` sets "no project". */
+    readonly projectId: string | null;
+}
+
 export declare type KayAppSessionProvenanceRecord = SessionProvenanceRecord;
 
 export declare type KayAppSessionRelationship = SessionRelationship;
@@ -6438,7 +7758,7 @@ export declare type KayAppSessionRunOutcome = (KayAppSessionRunBase & {
     readonly existingSessionId: string;
 };
 
-export declare type KayAppSessionRunState = "running" | "interrupted" | "cancelled" | "failed" | "completed";
+export declare type KayAppSessionRunState = AgentRuntimeSessionRunState;
 
 /** Settled run outcomes of one session, tallied from its log. */
 export declare interface KayAppSessionRunTally {
@@ -6605,6 +7925,15 @@ export declare interface KayAppSessions {
     } | {
         readonly kind: "unavailable";
     }>;
+    /**
+     * Private API: only plugins Bonsai ships; refused for any other. Set the project of any stored
+     * sessions, each only while it still holds the project the caller last saw (a compare-and-set,
+     * so a person's own choice made meanwhile always wins). Answers one boolean per assignment, in
+     * order: `false` when the session is gone or its project changed. A written session's project
+     * folder and prompt block are refreshed. Checked against `sessions.assign-project`; a refused
+     * call rejects.
+     */
+    assignProject?(assignments: readonly KayAppSessionProjectAssignment[]): Promise<readonly boolean[]>;
     /**
      * Run one hidden headless system session through Bonsai's harness and resolve
      * with its final output - the sole sanctioned way for a `kay.app` plugin to
@@ -6763,10 +8092,10 @@ export declare interface KayAppSessionSummaryResult {
 }
 
 /** How a session's work is judged to have served the user. `"unclear"` is a real answer, not a failure. */
-export declare type KayAppSessionVerdict = "good" | "mixed" | "bad" | "unclear";
+export declare type KayAppSessionVerdict = AgentRuntimeSessionOutcomeVerdict;
 
 /** The judge's own certainty: a tuning filter, never a weight the reader applies. */
-export declare type KayAppSessionVerdictConfidence = "low" | "medium" | "high";
+export declare type KayAppSessionVerdictConfidence = AgentRuntimeSessionOutcomeConfidence;
 
 export declare interface KayAppSessionWorkSummary {
     readonly goal: string;
@@ -7692,6 +9021,12 @@ export declare interface KayAppSystemPromptFragment {
      * KayAppSystemPromptRegistration.refresh}.
      */
     readonly maxAgeMs?: number;
+    /**
+     * For text about the chat's project. A forked chat starts with its parent's texts unchanged, so
+     * the model's prompt cache still matches; when set, a fork whose project is then chosen drops the
+     * parent's copy of this text and renders its own. Absent: a fork keeps the parent's text.
+     */
+    readonly forksFollowProject?: boolean;
     /** The text, or `undefined` for none. A rejection leaves the text out and is logged. */
     render(request: KayAppSystemPromptRenderRequest): Promise<string | undefined>;
 }
@@ -7722,7 +9057,7 @@ export declare interface KayAppSystemPromptRenderRequest {
 }
 
 /** Bonsai's reasoning-effort ladder, in ascending order. */
-export declare type KayAppThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export declare type KayAppThinkingLevel = AgentRuntimeThinkingLevel;
 
 /**
  * `app.time` / `api.time`: host facts about time. Added to `kay.app` in SDK 0.12.1 and to
@@ -8673,7 +10008,7 @@ export declare type KayAppWorkspaceCommand = {
  * The one outcome grammar every {@link KayAppWorkspaceCommand} resolves to. A JSON-safe twin of
  * `WorkspaceCommandOutcome` in `@bonsai/agent-runtime-protocol`.
  */
-export declare type KayAppWorkspaceCommandOutcome = "applied" | "opened" | "focused-existing" | "no-room" | "no-window" | "not-found" | "invalid";
+export declare type KayAppWorkspaceCommandOutcome = WorkspaceCommandOutcome;
 
 /** Session attribution required on every {@link KayAppWorkspace.execute} call; see the host type's doc comment. */
 export declare interface KayAppWorkspaceExecuteContext {
@@ -8682,14 +10017,12 @@ export declare interface KayAppWorkspaceExecuteContext {
 
 /**
  * The plugin-facing `kay.app` workspace contract (`app.workspace`): the desktop workspace snapshot
- * and the arrangement commands a plugin may run. This package does not import
- * `@bonsai/agent-runtime-protocol`, so these types are JSON-safe, hand-copied twins of that
- * package's workspace shapes. Changes to this contract belong in this module.
+ * and the arrangement commands a plugin may run. Snapshot tabs and command outcomes reuse the
+ * runtime protocol; command inputs retain the plugin's narrower arrangement authority.
  */
 /**
  * What one pane item shows. A JSON-safe, hand-copied twin of `WorkspacePaneContent` in
- * `@bonsai/agent-runtime-protocol` - this package cannot import that protocol package (see this
- * module's own doc comment), so the shape is re-declared here. A parity check in `@bonsai/agent-runtime`
+ * `@bonsai/agent-runtime-protocol`. A parity check in `@bonsai/agent-runtime`
  * asserts `app.workspace` (the runtime's `KayWorkspaceCapability`, built from the protocol types)
  * stays structurally assignable to {@link KayAppWorkspace} below.
  *
@@ -8777,15 +10110,7 @@ export declare interface KayAppWorkspaceSnapshot {
 /** The tab-group colour palette, by name (Chrome's nine); mirrors the wire schema's enum. */
 export declare type KayAppWorkspaceTabGroupColor = "grey" | "blue" | "red" | "yellow" | "green" | "pink" | "purple" | "cyan" | "orange";
 
-export declare interface KayAppWorkspaceTabSnapshot {
-    readonly id: string;
-    readonly label: string;
-    readonly active: boolean;
-    readonly variable?: boolean | undefined;
-    readonly focusedPaneId: string;
-    readonly maximizedPaneId: string | null;
-    readonly root: KayAppWorkspacePaneNode;
-}
+export declare type KayAppWorkspaceTabSnapshot = ReadonlyContract<WorkspaceTabSnapshot>;
 
 /**
  * Each method writes one line. `name` is a stable event name (`sync-failed`), the same for every
@@ -8866,6 +10191,20 @@ export declare interface KayPluginSimulatorOptions {
     readonly stateRoot: string;
 }
 
+/** A declared module exports this function; input and output must be JSON values. */
+export declare interface KayPluginWorkerModule {
+    run(input: unknown): unknown | Promise<unknown>;
+}
+
+/** Run only this plugin's declared modules in a fresh child owned by its hosting process. */
+export declare interface KayPluginWorkers {
+    /** The host terminates the child on deadline, caller abort or plugin disposal. */
+    run<T = unknown>(workerId: string, input: unknown, options: {
+        readonly timeoutMs: number;
+        readonly signal?: AbortSignal;
+    }): Promise<T>;
+}
+
 /** Applies a KeyOf action to the given type. */
 declare function KeyOf<Type extends TSchema>(type: Type, options?: TSchemaOptions): TKeyOf_2<Type>;
 
@@ -9012,6 +10351,90 @@ declare type MatchTrueLike = (inferred: TProperties) => unknown;
 /** The most labels a recorded choice question may offer, and so the most one filter names. */
 export declare const MAX_CHOICE_LABELS = 64;
 
+/** The connection state published for one configured MCP server. */
+export declare type McpServerConnectionState = "disconnected" | "connecting" | "connected" | "needs-auth" | "failed";
+
+/** A server mark already resolved into a data URI by its publisher. */
+export declare interface McpServerIcon {
+    /** A `data:` URI. Consumers may render it directly in an `<img src>`. */
+    readonly src: string;
+    /**
+     * Where the mark came from, because the two are not equally trustworthy.
+     *
+     * `declared` is the server's own `serverInfo.icons` (MCP spec 2025-11-25, SEP-973): evidence.
+     * `favicon` is derived from an HTTP server's origin: still evidence, one step removed.
+     * A name match against Bonsai's brand table is neither, and deliberately does not appear here -
+     * that guess lives in the renderer's existing `BrandIcon` fallback, below both of these.
+     */
+    readonly source: "declared" | "favicon";
+    /** The theme the server nominated this variant for, when it declared more than one. */
+    readonly theme?: "light" | "dark";
+}
+
+/** One keyed change to the MCP inventory. */
+export declare type McpServerInventoryChange = {
+    readonly kind: "upsert";
+    readonly server: McpServerRecord;
+} | {
+    readonly kind: "remove";
+    readonly name: string;
+};
+
+/** One configured MCP server in the app-facing inventory. */
+export declare interface McpServerRecord {
+    /** The config key, and the id the `mcp.<name>` auth service keys on. */
+    readonly name: string;
+    /**
+     * The auth service that connects this server, when it has one: `mcp.<name>` for a plugins.mcp
+     * server, the shipping plugin's own service for a vendored one. The Plugins page joins a
+     * connection row to its server on THIS id - never by deriving a name from the service id,
+     * which only ever fit the user-config namespace and left every vendored server toolless.
+     */
+    readonly authServiceId?: string;
+    /** The server's own `serverInfo.title`, when it sent one. Display prefers it over `name`. */
+    readonly title?: string;
+    readonly transport: "stdio" | "http";
+    /** What the server launches or connects to: joined command for stdio, url for http. */
+    readonly target: string;
+    /** The config-level switch (`enabled: false` in `plugins.mcp`), not the connection. */
+    readonly enabled: boolean;
+    readonly state: McpServerConnectionState;
+    /** Live when connected, else from the persisted metadata cache. Zero is ordinary. */
+    readonly toolCount: number;
+    /**
+     * What this server offers, for a surface that lists it. Live when connected, else from the
+     * persisted metadata cache, so a server names its tools before it has connected this session
+     * and after a restart.
+     *
+     * NAMES AND DESCRIPTIONS ONLY. The JSON-Schema input declarations stay out: they are by far the
+     * biggest part of a tool list, nothing on this surface renders them, and this snapshot is
+     * re-encoded whenever any server changes state. A surface that genuinely needs a schema is
+     * asking a different question and should ask the agent bridge, which owns tool detail.
+     *
+     * Bounded by the publisher's tool-list limit - {@link toolCount} remains the true count, so a
+     * server past the bound still reports honestly even though the list is clipped.
+     */
+    readonly tools?: readonly McpServerToolSummary[];
+    readonly icon?: McpServerIcon;
+    /**
+     * Why a `failed` server failed, in one human-legible line, when the host knows. A broken row can
+     * then say what went wrong instead of only offering Retry.
+     */
+    readonly failure?: string;
+}
+
+/** A complete MCP inventory snapshot. */
+export declare interface McpServersSnapshot {
+    readonly servers: readonly McpServerRecord[];
+}
+
+/** A tool name and optional description for inventory presentation. */
+export declare interface McpServerToolSummary {
+    readonly name: string;
+    /** The server's own one-line description, trimmed to the publisher's summary limit. */
+    readonly description?: string;
+}
+
 export declare namespace Memory {
     export {
         Assign,
@@ -10241,6 +11664,15 @@ export declare interface PluginUriWriteOptions extends PluginUriMutationOptions
     readonly writeSource?: UriSourceDescriptor;
 }
 
+/** A worker refusal or failure; the code is safe to record without its input or output. */
+export declare class PluginWorkerError extends Error {
+    readonly code: PluginWorkerErrorCode;
+    constructor(code: PluginWorkerErrorCode, message?: string);
+}
+
+/** Stable, content-free failure classes for a plugin worker request. */
+export declare type PluginWorkerErrorCode = "undeclared" | "invalid_module" | "invalid_input" | "input_too_large" | "output_too_large" | "timeout" | "aborted" | "spawn_failed" | "child_failed" | "invalid_output";
+
 export declare interface PreparedAccessApproval {
     readonly uri: string;
     readonly content: Record<string, unknown>;
@@ -10256,6 +11688,33 @@ export declare interface PreparedAccessApproval {
     readonly binding?: unknown;
 }
 
+export declare const ProjectDirectory: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    defaultCwd: z.ZodString;
+    ancestorIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+
+export declare type ProjectDirectory = z.infer<typeof ProjectDirectory>;
+
+export declare const ProjectDirectoryRequest: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strict>;
+
+export declare type ProjectDirectoryRequest = z.infer<typeof ProjectDirectoryRequest>;
+
+/** `project` is null when no project has the requested id. */
+export declare const ProjectDirectoryResponse: z.ZodObject<{
+    project: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        defaultCwd: z.ZodString;
+        ancestorIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+
+export declare type ProjectDirectoryResponse = z.infer<typeof ProjectDirectoryResponse>;
+
 declare const Properties: (input: string) => [unknown, string] | [];
 
 declare function PropertiesMapping(input: [unknown, unknown, unknown]): unknown;
@@ -10300,6 +11759,31 @@ declare function PropertyMapping(input: [unknown, unknown, unknown, unknown, unk
 /** Extracts a tuple of property values from a TProperties value. */
 declare function PropertyValues<Properties extends TProperties>(properties: Properties): TPropertyValues<Properties>;
 
+declare const ProvenanceGapCode: z.ZodEnum<{
+    "legacy-run-id-missing": "legacy-run-id-missing";
+    "mutation-revision-missing": "mutation-revision-missing";
+    "partial-git-provenance": "partial-git-provenance";
+    "git-session-stamp-missing": "git-session-stamp-missing";
+    "external-resource-unnamed": "external-resource-unnamed";
+    "produced-resource-unnamed": "produced-resource-unnamed";
+    "skill-suggestion-unattributable": "skill-suggestion-unattributable";
+    "malformed-source-record": "malformed-source-record";
+    "source-unreadable": "source-unreadable";
+    "git-revision-unavailable": "git-revision-unavailable";
+    "automation-history-unavailable": "automation-history-unavailable";
+    "session-history-unavailable": "session-history-unavailable";
+    "required-evidence-missing": "required-evidence-missing";
+}>;
+
+declare type ProvenanceGapCode = z.infer<typeof ProvenanceGapCode>;
+
+declare type ProvenancePage<T> = {
+    readonly items: readonly T[];
+    readonly totalCount: number;
+    readonly nextCursor?: string;
+    readonly truncated: boolean;
+};
+
 declare type ProviderId = KnownProvider | string;
 
 /**
@@ -10409,6 +11893,10 @@ declare function Readonly_2<Type extends TSchema>(type: Type): TAddReadonly<Type
 
 declare const Readonly_3: (input: string) => [unknown, string] | [];
 
+declare type ReadonlyContract<T> = T extends readonly (infer Item)[] ? readonly ReadonlyContract<Item>[] : T extends object ? {
+    readonly [Key in keyof T]: ReadonlyContract<T[Key]>;
+} : T;
+
 declare type ReadonlyKeys<Properties extends TProperties, Result extends PropertyKey = {
     [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? never : Key) : never;
 }[keyof Properties]> = Result;
@@ -17466,18 +18954,78 @@ declare const WithValue: (input: string) => [unknown, string] | [];
 
 declare function WithValueMapping(input: unknown): unknown;
 
-declare type WorkBlockCoverage = z.infer<typeof WorkBlockCoverageSchema>;
+declare const WorkspaceCommandOutcome: z.ZodEnum<{
+    invalid: "invalid";
+    opened: "opened";
+    "focused-existing": "focused-existing";
+    "no-room": "no-room";
+    "no-window": "no-window";
+    "not-found": "not-found";
+    applied: "applied";
+}>;
+
+declare type WorkspaceCommandOutcome = z.infer<typeof WorkspaceCommandOutcome>;
+
+declare const WorkspacePaneItem: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"session">;
+        sessionId: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"browser">;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"artifact">;
+        uri: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"page">;
+        pageId: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        objectId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"launcher">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"terminal">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+
+declare type WorkspacePaneItem = z.infer<typeof WorkspacePaneItem>;
 
 /**
- * Exact ordered completed executions, addressed by persisted tool-result entry IDs.
- * Provider call IDs can repeat across retries and turns; they are never ownership keys.
+ * One node in a tab's pane tree: a leaf holding pane items, or a split dividing space between children.
+ * Recursive - declared as a hand-written TS type first (the standard zod recursive pattern), then
+ * tied to a `z.lazy` schema whose inferred shape the type annotation holds to.
  */
-declare const WorkBlockCoverageSchema: z.ZodObject<{
-    firstToolResultEntryId: z.ZodString;
-    lastToolResultEntryId: z.ZodString;
-    toolResultEntryIds: z.ZodArray<z.ZodString>;
+declare type WorkspacePaneNode = {
+    type: "leaf";
+    id: string;
+    items: readonly WorkspacePaneItem[];
+    activeItemId: string;
+} | {
+    type: "split";
+    id: string;
+    orientation: "row" | "column";
+    weights: readonly number[];
+    children: readonly WorkspacePaneNode[];
+};
+
+declare const WorkspacePaneNode: z.ZodType<WorkspacePaneNode>;
+
+declare const WorkspaceTabSnapshot: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    active: z.ZodBoolean;
+    variable: z.ZodOptional<z.ZodBoolean>;
+    focusedPaneId: z.ZodString;
+    maximizedPaneId: z.ZodNullable<z.ZodString>;
+    root: z.ZodType<WorkspacePaneNode, unknown, z.core.$ZodTypeInternals<WorkspacePaneNode, unknown>>;
 }, z.core.$strict>;
 
+declare type WorkspaceTabSnapshot = z.infer<typeof WorkspaceTabSnapshot>;
+
 declare interface XAdditionalItems<AdditionalItems extends XSchema = XSchema> {
     additionalItems: AdditionalItems;
 }