@pstdio/sdk 0.20.0 → 0.22.0

package/dist/extensions.d.ts

@@ -0,0 +1,3826 @@
+import { z } from 'zod';
+
+export declare interface ActionOption {
+    id: string;
+    name: string;
+    icon?: string;
+    disabled?: boolean;
+}
+
+/** Compact command set rendered as an action button row. */
+export declare interface ActionsControl extends BaseControl {
+    type: "actions";
+    defaultValue?: string;
+    options: ActionOption[];
+}
+
+export declare interface ActivityItemContribution<TParams extends Struct = Struct> extends ContributionDefinition<"activity-item"> {
+    title: Localizable<string>;
+    icon: string;
+    /** Mode ids whose activity rail shows this item. */
+    modes: readonly ModeRef[];
+    placement?: "first" | "default" | "last";
+    command: CommandRef<TParams, unknown>;
+    params?: Partial<TParams>;
+}
+
+export declare type AgentCapability = "SessionFork" | "ContextUsage" | "Approvals" | "SessionReattach";
+
+export declare type AgentModel = z.infer<typeof agentModelSchema>;
+
+declare const agentModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    paramOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodLiteral<"select">;
+        defaultValue: z.ZodOptional<z.ZodString>;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+            icon: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            $l10n: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodLiteral<"boolean">;
+        defaultValue: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>>>>;
+}, z.core.$strip>;
+
+export declare const ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES: readonly ["host.dispatchKeyboardEvent"];
+
+/** Nine-point alignment picker. */
+export declare interface AnchorGridControl extends BaseControl {
+    type: "anchorGrid";
+    defaultValue: AnchorGridValue;
+}
+
+export declare type AnchorGridValue = "top-left" | "top" | "top-right" | "left" | "center" | "right" | "bottom-left" | "bottom" | "bottom-right";
+
+export declare type ApprovalRequest = {
+    id: string;
+    toolName: string;
+    toolInput: unknown;
+    toolUseId: string;
+};
+
+export declare type ApprovalResponse = {
+    id: string;
+    decision: "approve" | "deny" | "timeout";
+};
+
+export declare interface ArtifactFile {
+    path: string;
+    size?: number;
+    updatedAt?: string;
+}
+
+export declare interface ArtifactMount {
+    exists(path: string): Promise<boolean>;
+    readText(path: string): Promise<string>;
+    writeText(path: string, value: string): Promise<void>;
+    readBytes(path: string): Promise<Uint8Array>;
+    writeBytes(path: string, value: Uint8Array): Promise<void>;
+    list(pattern?: string): Promise<ArtifactFile[]>;
+    listDirs(path?: string): Promise<string[]>;
+    delete(path: string): Promise<void>;
+}
+
+export declare interface ArtifactMountContribution extends ContributionDefinition<"artifact-mount"> {
+    /** Relative path under .pstdio/<extension.name>/. */
+    path: string;
+    label: Localizable<string>;
+    repoRole?: "default" | "selected" | "workspace";
+}
+
+export declare const artifactMountId: (mount: ArtifactMountKey) => string;
+
+/** An artifact mount reference: the contribution, its ref, or the mount's local id. */
+export declare type ArtifactMountKey = string | {
+    id: string;
+};
+
+/**
+ * Declare webview read access to one artifact mount the extension defines.
+ * Each mount is a separate grant; there is no wildcard.
+ *
+ * @example
+ *   capabilities: ["commands.execute", artifactsRead(runArtifacts)]
+ */
+export declare const artifactsRead: (mount: ArtifactMountKey) => WebviewCapabilityDeclaration;
+
+/** Static asset contributions: artifact mounts, templates, skills. */
+export declare interface AssetContributions {
+    artifactMounts?: readonly ArtifactMountContribution[];
+    templateTypes?: readonly TemplateTypeContribution[];
+    templates?: readonly TemplateContribution[];
+    skills?: readonly SkillContribution[];
+    themes?: readonly ThemeContribution[];
+    fileIconThemes?: readonly FileIconThemeContribution[];
+    translations?: Record<string, PackageAssetDescriptor>;
+    defaultLocale?: string;
+}
+
+export declare interface BaseControl {
+    id: string;
+    name: string;
+    description?: string;
+    /** Locks this one param while the rest of the editor stays editable. */
+    readOnly?: boolean;
+}
+
+/** Behavioural surface: commands, middleware, hooks, schedules. */
+export declare interface BehaviourContributions {
+    commands?: readonly CommandDefinition<any, any, any>[];
+    middlewares?: readonly MiddlewareDefinition<any, any>[];
+    hooks?: readonly HookDefinition<any>[];
+    schedules?: readonly ScheduleContribution<any>[];
+}
+
+export declare interface BooleanControl extends BaseControl {
+    type: "boolean";
+    defaultValue: boolean;
+}
+
+export declare type BooleanParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<boolean, TRequired> & {
+    type: "boolean";
+};
+
+export declare interface CliContribution {
+    path?: string[];
+    globalAliases?: string[][];
+    description?: Localizable<string>;
+    examples?: string[];
+    hidden?: boolean;
+}
+
+declare type ClientSettingsMap<TSettings> = TSettings extends {
+    properties: unknown;
+} ? SettingsMap<TSettings> : Record<never, never>;
+
+export declare interface CollectionBadgeItem {
+    id: string;
+    label: string;
+    icon?: string;
+    resource?: ResourceRef;
+}
+
+export declare interface ColorControl extends BaseControl {
+    type: "color";
+    defaultValue: string;
+}
+
+export declare interface CommandCompletedEvent<TParams extends Struct = Struct, TResult = unknown> extends CommandStartedEvent<TParams> {
+    result: TResult;
+    elapsedMs: number;
+}
+
+export declare interface CommandContext<TSettings extends Record<string, unknown> = Record<string, unknown>> extends ExtensionContextBase<TSettings> {
+    commandId: string;
+    invocationId: string;
+    /** Aborts when the host cancels this command run. Handlers must stop external side effects when it fires. */
+    signal: AbortSignal;
+    invocation: {
+        readonly source?: CommandSource;
+        readonly attachment?: WorkbenchAttachmentInvocationContext;
+        readonly slot?: SlotInvocationContext;
+        readonly metadata?: JsonObject;
+    };
+    resource?: ResourceRef;
+    attachment?: WorkbenchAttachmentInvocationContext;
+    slot?: SlotInvocationContext;
+}
+
+export declare interface CommandContinue {
+    type: "continue";
+}
+
+declare type CommandContribution<TSchema extends ParamObjectSchema | undefined, TResult> = CommandDefinition<TSchema, TResult> & ContributionDefinition<"command">;
+
+/**
+ * A command exposed by an extension. The `params` schema (typed via `params.*`) drives
+ * the inferred shape of the second argument passed to `run`.
+ */
+export declare interface CommandDefinition<TSchema extends ParamObjectSchema | undefined = ParamObjectSchema | undefined, TResult = unknown, TSettings extends Record<string, unknown> = Record<string, unknown>> extends ContributionDefinition<"command"> {
+    readonly ref: CommandRef<SchemaParams<TSchema>, TResult>;
+    title: Localizable<string>;
+    description?: Localizable<string>;
+    params?: TSchema;
+    menus?: readonly MenuContribution[];
+    palette?: readonly CommandPaletteContribution<SchemaParams<TSchema>>[];
+    cli?: true | CliContribution;
+    /** Exposes this exact command and its params schema to scoped machine tokens. */
+    automation?: true;
+    /** Records CLI invocations of this command as mutations. */
+    mutating?: true;
+    run: CommandRunHandler<SchemaParams<TSchema>, TResult, TSettings>;
+}
+
+export declare interface CommandDiagnostic {
+    code: string;
+    message: string;
+    severity: "info" | "warning" | "error";
+    extensionId?: string;
+    commandId?: string;
+    metadata?: JsonObject;
+}
+
+/**
+ * Build an `EventRef` for a command lifecycle phase (`requested`, `started`, `completed`,
+ * `rejected`, `failed`). The payload type is inferred from the command ref so hooks see
+ * the correct shape.
+ */
+export declare const commandEvent: <TPhase extends CommandLifecyclePhase, TParams extends Struct = Struct, TResult = unknown>(command: CommandRef<TParams, TResult>, phase: TPhase) => EventRef<CommandLifecycleEventPayload<TPhase, TParams, TResult>>;
+
+export declare interface CommandFailedEvent<TParams extends Struct = Struct> extends CommandRequestedEvent<TParams> {
+    code?: string;
+    reason: string;
+    error?: SerializedError;
+    elapsedMs: number;
+}
+
+declare type CommandFn<TDefinition> = TDefinition extends CommandDefinition<infer TSchema, infer TResult, infer _TSettings> ? TSchema extends ParamObjectSchema ? Partial<ParamsOf<TSchema>> extends ParamsOf<TSchema> ? (params?: ParamsOf<TSchema>) => Promise<TResult> : (params: ParamsOf<TSchema>) => Promise<TResult> : () => Promise<TResult> : never;
+
+export declare interface CommandHelpersApi {
+    execute<TParams extends Struct = Struct, TResult = unknown>(command: CommandRef<TParams, TResult>, invocation: CommandInvocation<TParams>): Promise<CommandOutcome<TResult>>;
+    continue(): CommandContinue;
+    patchParams<TParams extends Struct = Struct>(params: Partial<TParams>): CommandPatchParams<TParams>;
+    replaceParams<TParams extends Struct = Struct>(params: TParams): CommandReplaceParams<TParams>;
+    replaceInvocation<TParams extends Struct = Struct>(invocation: CommandInvocation<TParams>): CommandReplaceInvocation<TParams>;
+    reject(input: Omit<CommandReject, "type">): CommandReject;
+}
+
+declare type CommandInput<TSchema extends ParamObjectSchema | undefined, TResult> = Omit<CommandDefinition<TSchema, TResult>, "ref">;
+
+export declare interface CommandInvocation<TParams extends Struct = Struct> {
+    params: TParams;
+    resource?: ResourceRef;
+    repoId?: string;
+    repoPath?: string;
+    attachment?: WorkbenchAttachmentInvocationContext;
+    slot?: SlotInvocationContext;
+    metadata?: JsonObject;
+}
+
+export declare type CommandLifecycleEventPayload<TPhase extends CommandLifecyclePhase, TParams extends Struct = Struct, TResult = unknown> = TPhase extends "requested" ? CommandRequestedEvent<TParams> : TPhase extends "started" ? CommandStartedEvent<TParams> : TPhase extends "completed" ? CommandCompletedEvent<TParams, TResult> : TPhase extends "rejected" ? CommandRejectedEvent<TParams> : CommandFailedEvent<TParams>;
+
+export declare type CommandLifecyclePhase = "requested" | "started" | "completed" | "rejected" | "failed";
+
+export declare type CommandMiddlewareContext = CommandContext;
+
+export declare type CommandMiddlewareHandler<TParams extends Struct = Struct> = (ctx: CommandMiddlewareContext, params: TParams) => MaybePromise<CommandMiddlewareResult<TParams>>;
+
+export declare type CommandMiddlewareResult<TParams extends Struct = Struct> = void | CommandContinue | CommandPatchParams<TParams> | CommandReplaceParams<TParams> | CommandReplaceInvocation<TParams> | CommandReject;
+
+export declare interface CommandNotice {
+    type: "info" | "success" | "warning" | "error";
+    title?: string;
+    message: string;
+    metadata?: JsonObject;
+}
+
+export declare type CommandOutcome<TResult = unknown> = {
+    ok: true;
+    status: "success";
+    value: TResult;
+    notices?: CommandNotice[];
+    diagnostics?: CommandDiagnostic[];
+} | {
+    ok: false;
+    status: "rejected";
+    code?: string;
+    reason: string;
+    data?: JsonObject;
+    notices?: CommandNotice[];
+    diagnostics?: CommandDiagnostic[];
+} | {
+    ok: false;
+    status: "error";
+    code?: string;
+    reason: string;
+    error?: SerializedError;
+    notices?: CommandNotice[];
+    diagnostics?: CommandDiagnostic[];
+};
+
+export declare interface CommandPaletteContribution<TParams extends Struct = Struct> {
+    label?: Localizable<string>;
+    group?: string;
+    placement?: "first" | "default" | "last";
+    icon?: string;
+    when?: WhenExpression;
+    params?: Partial<TParams>;
+}
+
+export declare interface CommandPaletteResourceContribution extends ContributionDefinition<"command-palette-resource"> {
+    title: Localizable<string>;
+    resourceKind?: ResourceKindRef;
+    query: RendererCallback<CommandPaletteResourceQueryParams, CommandPaletteResourceQueryResult>;
+    refreshEvents?: readonly RendererEventReference[];
+}
+
+export declare interface CommandPaletteResourceItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    keywords?: string[];
+    target: CommandPaletteResourceTarget;
+}
+
+/**
+ * Command palette resource providers contribute dynamic, searchable palette results
+ * (e.g. slides in a presentation) backed by a private query callback. The host queries
+ * matching providers as the user types and refreshes results when a declared event fires.
+ */
+export declare interface CommandPaletteResourceQueryParams {
+    projectId?: string;
+    modeId?: string;
+    activeResource?: ResourceRef;
+    providerId: string;
+    query: string;
+    limit: number;
+}
+
+export declare interface CommandPaletteResourceQueryResult {
+    items: CommandPaletteResourceItem[];
+}
+
+export declare type CommandPaletteResourceTarget = NavigationTarget;
+
+export declare interface CommandPatchParams<TParams extends Struct = Struct> {
+    type: "patchParams";
+    params: Partial<TParams>;
+}
+
+export declare interface CommandRef<TParams extends Struct = Struct, TResult = unknown> extends ContributionRef<"command"> {
+    params?: TParams;
+    result?: TResult;
+}
+
+/** Build a typed cross-extension command reference. */
+export declare const commandRef: CommandRefFactory;
+
+declare interface CommandRefFactory {
+    <TParams extends Struct = Struct, TResult = unknown>(input: ExternalRefInput): CommandRef<TParams, TResult>;
+    forExtension(owner: ExtensionOwner): <TParams extends Struct = Struct, TResult = unknown>(id: string) => CommandRef<TParams, TResult>;
+}
+
+export declare interface CommandReject {
+    type: "reject";
+    code?: string;
+    reason: string;
+    data?: JsonObject;
+}
+
+export declare interface CommandRejectedEvent<TParams extends Struct = Struct> extends CommandRequestedEvent<TParams> {
+    code?: string;
+    reason: string;
+    data?: JsonObject;
+}
+
+export declare interface CommandReplaceInvocation<TParams extends Struct = Struct> {
+    type: "replaceInvocation";
+    invocation: CommandInvocation<TParams>;
+}
+
+export declare interface CommandReplaceParams<TParams extends Struct = Struct> {
+    type: "replaceParams";
+    params: TParams;
+}
+
+export declare interface CommandRequestedEvent<TParams extends Struct = Struct> {
+    commandId: string;
+    invocationId: string;
+    source?: CommandSource;
+    params: TParams;
+    resource?: ResourceRef;
+    repo?: RepoContext;
+}
+
+export declare type CommandResponse<TResult = unknown> = {
+    outcome: CommandOutcome<TResult>;
+};
+
+export declare type CommandRunHandler<TParams extends Struct = Struct, TResult = unknown, TSettings extends Record<string, unknown> = Record<string, unknown>> = (ctx: CommandContext<TSettings>, params: TParams) => MaybePromise<TResult>;
+
+export declare type CommandSource = "cli" | "dashboard" | "api" | "schedule" | "event" | "automation" | "command-panel";
+
+export declare interface CommandStartedEvent<TParams extends Struct = Struct> extends CommandRequestedEvent<TParams> {
+}
+
+export declare interface CommandTarget<TParams extends Struct = Struct> {
+    command: CommandRef<TParams, unknown>;
+    params?: TParams;
+}
+
+export declare interface CommitPayload {
+    projectId: string;
+    repoPath?: string;
+    worktreePath?: string;
+    branch?: string;
+    commitSha?: string;
+    workspace?: ExtensionWorkspace;
+    anchors?: ResourceAnchor[];
+}
+
+export declare interface ConflictPayload {
+    projectId: string;
+    operation: "rebase" | "merge";
+    repoPath?: string;
+    worktreePath?: string;
+    branch?: string;
+    workspace?: ExtensionWorkspace;
+    anchors?: ResourceAnchor[];
+}
+
+export declare type ConnectionRef = ContributionRef<"connection">;
+
+export declare interface ContributionDefinition<Kind extends ContributionKind> {
+    readonly id: string;
+    readonly ref: ContributionRef<Kind>;
+}
+
+export declare type ContributionInput<Kind extends ContributionKind> = Omit<ContributionDefinition<Kind>, "ref">;
+
+export declare type ContributionKind = "activity-item" | "artifact-mount" | "command" | "command-palette-resource" | "connection" | "file-icon-theme" | "harness" | "hook" | "keybinding" | "middleware" | "mode" | "navigation-item" | "navigation-tree" | "page" | "placement" | "resource-hierarchy-provider" | "resource-kind" | "schedule" | "settings-panel" | "settings-section" | "skill" | "status" | "status-bar-item" | "template" | "template-type" | "theme" | "view" | "view-menu" | "workspace-type";
+
+export declare interface ContributionRef<Kind extends ContributionKind> {
+    readonly extensionId?: string;
+    readonly kind: Kind;
+    readonly id: string;
+}
+
+export declare interface ControlGroup {
+    id: string;
+    title: string;
+    description?: string;
+    params: ControlParam[];
+    collapsible?: boolean;
+    defaultCollapsed?: boolean;
+}
+
+export declare type ControlParam = NumberControl | BooleanControl | TextControl | MarkdownControl | SelectionControl | DateControl | ColorControl | ReadOnlyControl | ResourceControl | RangeControl | SegmentedControl | ActionsControl | AnchorGridControl | VectorControl;
+
+export declare interface ControlsApplyInput {
+    renderer: RendererContext;
+    values: ControlValueMap;
+}
+
+export declare interface ControlsQueryParams {
+    renderer: RendererContext;
+}
+
+export declare interface ControlsQueryResult {
+    params?: ControlParam[];
+    groups?: ControlGroup[];
+    values?: ControlValueMap;
+    readOnly?: boolean;
+}
+
+/** A native controls view. Its query supplies serializable fields and their current values. */
+export declare interface ControlsRendererContribution extends RendererContributionBase {
+    query: RendererCallback<ControlsQueryParams, ControlsQueryResult>;
+    onValueChange?: RendererCallback<ControlsUpdateValueInput, unknown>;
+    onApply?: RendererCallback<ControlsApplyInput, unknown>;
+    onReset?: RendererCallback<ControlsResetInput, unknown>;
+    defaultValues?: ControlValueMap;
+}
+
+export declare interface ControlsResetInput {
+    renderer: RendererContext;
+    controlIds?: string[];
+}
+
+export declare type ControlsResourceRef = ResourceRef;
+
+export declare interface ControlsUpdateValueInput {
+    renderer: RendererContext;
+    controlId: string;
+    value: ControlValue;
+    values: ControlValueMap;
+}
+
+export declare type ControlsViewBody = NativeViewBody<"controls", ControlsRendererContribution>;
+
+export declare type ControlValue = number | string | boolean | null | string[] | RangeValue | VectorValue;
+
+export declare type ControlValueMap = Record<string, ControlValue>;
+
+export declare interface CreateExtensionWorkspaceInput {
+    project_id?: string;
+    shorthand_base: string;
+    provider_id?: string;
+    params?: JsonObject;
+    anchors?: ResourceAnchor[];
+    repo_id?: string;
+    base?: string;
+}
+
+export declare interface CreateNotificationInput {
+    projectId: string;
+    title: string;
+    body?: string;
+    kind: NotificationKind;
+    priority?: NotificationPriority;
+    target?: ResourceRef;
+    related?: ResourceRef[];
+    actions?: NotificationAction[];
+    dedupeKey?: string;
+    expiresAt?: string;
+    snoozedUntil?: string;
+    metadata?: JsonObject;
+}
+
+/**
+ * Builds a terminal bridge for an extension webview from its `GuestHost`.
+ * Operations go through `host.call("terminal.session", ...)`; output and exit
+ * events arrive through the host event channel. The webview must declare the
+ * `terminal.session` capability or every call is rejected by the host gate.
+ */
+export declare const createTerminalSessionBridge: (host: GuestHost) => TerminalSessionBridge;
+
+/**
+ * Typed guest-side client over the host bridge. Command params and results come from
+ * the extension's exported commands record (`defineCommand` values); settings come
+ * from its exported settings contribution. Command outcomes are unwrapped, so
+ * failures throw.
+ *
+ * Import both as types only, so no server code enters the webview bundle:
+ *
+ * @example
+ *   import type { commands } from "../commands";
+ *   import type { settings } from "../settings";
+ *
+ *   const client = createWebviewClient<typeof commands, typeof settings>(host);
+ *   const { statuses } = await client.commands["ticket-status.read"]();
+ *   const enabled = await client.settings.get("counter.enabled");
+ */
+export declare const createWebviewClient: <TCommands extends object, TSettings = undefined>(host: GuestHost, options?: WebviewClientOptions) => WebviewClient<TCommands, TSettings>;
+
+export declare interface DataTableRendererColumn {
+    id: string;
+    label?: Localizable<string>;
+    description?: Localizable<string>;
+    icon?: string;
+    hidden?: boolean;
+    stat?: DataTableRendererColumnStat;
+    renderer?: DataTableRendererColumnRenderer;
+}
+
+export declare type DataTableRendererColumnRenderer = {
+    type: "json";
+} | {
+    type: "color-scale";
+    stops: Array<{
+        value: number;
+        color: DataTableRendererThemeColor;
+    }>;
+} | {
+    type: "categorical-color";
+    categories: Array<{
+        value: string | number | boolean | null;
+        color: DataTableRendererThemeColor;
+    }>;
+};
+
+export declare type DataTableRendererColumnStat = {
+    type: "unique";
+} | {
+    type: "histogram";
+    bins?: number;
+} | {
+    type: "top-values";
+    limit?: number;
+};
+
+export declare interface DataTableRendererContribution extends RendererContributionBase {
+    columns?: DataTableRendererColumn[];
+    query: RendererCallback<DataTableRendererQueryParams, DataTableRendererQueryResult>;
+    selectionMode?: "none" | "multiple";
+    selectionActions?: DataTableRendererSelectionAction[];
+    rowActions?: DataTableRendererRowAction[];
+    onRowActivate?: DataTableRendererRowActivationHandler;
+    initialPageSize?: number;
+    pageSizeOptions?: number[];
+}
+
+export declare interface DataTableRendererQueryParams {
+    renderer: RendererContext;
+}
+
+export declare interface DataTableRendererQueryResult {
+    rows: DataTableRendererRow[];
+    columns?: DataTableRendererColumn[];
+}
+
+export declare type DataTableRendererResourceRef = ResourceRef;
+
+export declare interface DataTableRendererRow {
+    id: string;
+    values: Record<string, JsonValue>;
+    resource?: DataTableRendererResourceRef;
+}
+
+export declare interface DataTableRendererRowAction<TParams extends Struct = Struct> {
+    id: string;
+    label: Localizable<string>;
+    icon?: string;
+    destructive?: boolean;
+    command: CommandRef<TParams, unknown>;
+}
+
+export declare type DataTableRendererRowActivationHandler = RendererCallback<{
+    row: DataTableRendererRow;
+}, undefined | NavigationTarget>;
+
+export declare interface DataTableRendererSelectionAction<TParams extends Struct = Struct> {
+    id: string;
+    label: Localizable<string>;
+    icon?: string;
+    destructive?: boolean;
+    command: CommandRef<TParams, unknown>;
+}
+
+export declare interface DataTableRendererThemeColor {
+    light: string;
+    dark: string;
+    foreground?: {
+        light: string;
+        dark: string;
+    };
+}
+
+export declare type DataTableViewBody = NativeViewBody<"dataTable", DataTableRendererContribution>;
+
+export declare interface DateControl extends BaseControl {
+    type: "date";
+    defaultValue: string;
+    min?: string;
+    max?: string;
+}
+
+export declare const defineActivityItem: <Definition extends Omit<ActivityItemContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"activity-item">;
+
+export declare const defineArtifactMount: <Definition extends Omit<ArtifactMountContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"artifact-mount">;
+
+/**
+ * Define a single command outside an extension's object literal. Use this when commands
+ * grow large enough to split into separate files, or when you need to share a command
+ * shape across extensions. The `params` schema drives the inferred shape of the
+ * handler's second argument.
+ *
+ * @example
+ *   export const sayHello = defineCommand({
+ *     title: "Say hello",
+ *     params: { name: params.text({ required: true }) },
+ *     async run(ctx, commandParams) {
+ *       commandParams.name; // string
+ *     },
+ *   });
+ */
+export declare function defineCommand<const TSchema extends ParamObjectSchema | undefined = undefined, TResult = unknown>(definition: CommandInput<TSchema, TResult>): CommandContribution<TSchema, TResult>;
+
+export declare const defineCommandPaletteResource: <Definition extends Omit<CommandPaletteResourceContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"command-palette-resource">;
+
+export declare const defineConnection: <Definition extends Omit<ExtensionConnectionContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"connection">;
+
+/**
+ * Type an extension's contribution arrays. Package identity stays in package.json.
+ * Use the contribution helpers so every independently addressable item has a local
+ * id and typed ref before it reaches this boundary.
+ */
+export declare const defineExtension: <const TDefinition extends ExtensionDefinition>(extension: NoExtraFields_2<TDefinition, ExtensionDefinition>) => NoExtraFields_2<TDefinition, ExtensionDefinition>;
+
+export declare const defineExtensionView: <TProps = unknown>(definition: {
+    render: ExtensionViewRender<TProps>;
+}) => ExtensionViewModule<TProps>;
+
+export declare const defineFileIconTheme: <Definition extends Omit<FileIconThemeContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"file-icon-theme">;
+
+export declare const defineHarness: <Definition extends Omit<HarnessProvider, "ref">>(definition: Definition) => Definition & ContributionDefinition<"harness">;
+
+/**
+ * Define a hook for an event.
+ */
+export declare const defineHook: <TPayload extends Struct = Struct>(definition: Omit<HookDefinition<TPayload>, "ref">) => HookDefinition<TPayload>;
+
+export declare const defineKeybinding: <Definition extends Omit<KeybindingContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"keybinding">;
+
+/**
+ * Define middleware for a command.
+ */
+export declare const defineMiddleware: <TParams extends Struct = Struct, TResult = unknown>(definition: Omit<MiddlewareDefinition<TParams, TResult>, "ref">) => MiddlewareDefinition<TParams, TResult>;
+
+export declare const defineMode: <const Definition extends ModeDefinition>(definition: NoExtraFields<Definition, ModeDefinition>) => Definition & ContributionDefinition<"mode">;
+
+export declare const defineNavigationItem: <const Definition extends NavigationItemDefinition>(definition: NoExtraFields<Definition, NavigationItemDefinition>) => Definition & ContributionDefinition<"navigation-item">;
+
+export declare const defineNavigationTree: <const Definition extends NavigationTreeDefinition>(definition: NoExtraFields<Definition, NavigationTreeDefinition>) => Definition & ContributionDefinition<"navigation-tree">;
+
+export declare const definePage: <const Definition extends PageDefinition>(definition: NoExtraFields<Definition, PageDefinition> & RequiredPageParent<Definition> & RequiredPageResource<Definition>) => Definition & ContributionDefinition<"page"> & {
+    readonly panels: PagePanelRefs<Definition["slots"]>;
+};
+
+export declare const definePlacement: <const Definition extends PlacementDefinition>(definition: NoExtraFields<Definition, PlacementDefinition>) => Definition & ContributionDefinition<"placement">;
+
+export declare const defineResourceHierarchyProvider: (definition: Omit<ResourceHierarchyProvider, "ref">) => {
+    ref: {
+        kind: "resource-hierarchy-provider";
+        id: string;
+    };
+    id: string;
+    resourceKind: ResourceKindRef;
+    parent: (ctx: ExtensionContextBase, resource: ResourceRef) => MaybePromise<ResourceRef | ViewHierarchyParent | null>;
+};
+
+export declare const defineResourceKind: <const Definition extends ResourceKindDefinitionInput>(definition: NoExtraFields<Definition, ResourceKindDefinitionInput>) => Definition & ContributionDefinition<"resource-kind">;
+
+export declare const defineSchedule: <Definition extends Omit<ScheduleContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"schedule">;
+
+export declare const defineSettingsPanel: <Definition extends Omit<SettingsPanelContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"settings-panel">;
+
+export declare const defineSettingsSection: <Definition extends Omit<SettingsSectionContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"settings-section">;
+
+export declare const defineSkill: <Definition extends Omit<SkillContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"skill">;
+
+/**
+ * Define a host-owned UI slot that extension contributions can target.
+ */
+export declare const defineSlot: <TContext extends Struct = Struct, TKind extends UiSlotKind = UiSlotKind>(id: string, options: SlotOptions<TKind>) => SlotRef<TContext, TKind>;
+
+export declare const defineStatusBarItem: <Definition extends Omit<StatusBarItemContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"status-bar-item">;
+
+export declare const defineStatuses: <Definition extends Omit<StatusContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"status">;
+
+export declare const defineTemplate: <Definition extends Omit<TemplateContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"template">;
+
+export declare const defineTemplateType: <Definition extends Omit<TemplateTypeContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"template-type">;
+
+export declare const defineTheme: <Definition extends Omit<ThemeContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"theme">;
+
+export declare const defineView: <const Definition extends ViewDefinition>(definition: NoExtraFields<Definition, ViewDefinition>) => Definition & ContributionDefinition<"view">;
+
+export declare const defineViewMenu: <const Definition extends ViewMenuDefinition>(definition: NoExtraFields<Definition, ViewMenuDefinition>) => Definition & ContributionDefinition<"view-menu">;
+
+export declare const defineWorkspaceType: <Definition extends Omit<WorkspaceTypeProvider, "ref">>(definition: Definition) => Definition & ContributionDefinition<"workspace-type">;
+
+export declare type DockedWorkbenchRegion = (typeof dockedWorkbenchRegions)[number];
+
+export declare const dockedWorkbenchRegions: readonly ["sidenav", "main", "secondary", "side"];
+
+export declare type ErrorPart = {
+    type: "error";
+    errorType: "timeout" | "crash" | "permission" | "other";
+    message?: string;
+};
+
+export declare interface EventContext extends ExtensionContextBase {
+    eventId: string;
+    deliveryId: string;
+}
+
+export declare interface EventDeliveryResult {
+    delivered: number;
+    diagnostics?: CommandDiagnostic[];
+}
+
+export declare interface EventRef<TPayload extends Struct = Struct> {
+    readonly extensionId?: string;
+    readonly kind: "event";
+    readonly id: string;
+    payload?: TPayload;
+}
+
+/** Build a typed event reference from separate ownership and local identity. */
+export declare const eventRef: <TPayload extends Struct = Struct>(input: ExternalRefInput) => EventRef<TPayload>;
+
+declare type ExactOptions<Definition, Contract> = unknown extends Contract ? Definition : [Contract] extends [Definition] ? Definition : Contract extends unknown ? Definition extends Contract ? Contract extends EventRef ? Definition : Definition extends (...args: never[]) => unknown ? Definition : Definition extends readonly unknown[] ? Contract extends readonly (infer Item)[] ? {
+    [Index in keyof Definition]: ExactOptions<Definition[Index], Item>;
+} : never : Definition extends object ? {
+    [Key in keyof Definition]: Key extends keyof Contract ? ExactOptions<Definition[Key], Contract[Key]> : never;
+} : Definition : never : never;
+
+/** Current host extension API version. `engines.pstdio` in package.json is a semver range checked against this. */
+export declare const EXTENSION_API_VERSION = "1.0.0-alpha.10";
+
+export declare interface ExtensionActivityApi {
+    record(input: {
+        message: string;
+        target?: ResourceRef;
+        related?: ResourceRef[];
+        metadata?: JsonObject;
+    }): Promise<{
+        id: string;
+    }>;
+}
+
+export declare interface ExtensionArtifactApi {
+    mount(key: string): ArtifactMount;
+}
+
+export declare interface ExtensionBlobInput {
+    name: string;
+    data: Uint8Array | ArrayBuffer;
+    mimeType?: string | null;
+}
+
+export declare interface ExtensionBlobRef {
+    id: string;
+    name: string;
+    mimeType: string | null;
+    size: number;
+    hash: string | null;
+    url: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare interface ExtensionBlobsApi {
+    put(input: ExtensionBlobInput): Promise<ExtensionBlobRef>;
+    get(id: string): Promise<ExtensionBlobRef | undefined>;
+    getBytes(id: string): Promise<Uint8Array>;
+    list(): Promise<ExtensionBlobRef[]>;
+    delete(id: string): Promise<void>;
+    urlFor(id: string): string;
+}
+
+export declare interface ExtensionConnectionContribution extends ContributionDefinition<"connection"> {
+    label: Localizable<string>;
+    transport: "http";
+    auth: {
+        type: "bearer";
+    } | {
+        type: "header";
+        headerName: string;
+    };
+    allowedMethods: readonly ("GET" | "POST" | "PUT" | "PATCH" | "DELETE")[];
+    allowedPathPrefixes: readonly string[];
+    check?: {
+        method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+        path: string;
+    };
+    supportsStreaming?: boolean;
+}
+
+export declare type ExtensionConnectionMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+export declare interface ExtensionConnectionRequest {
+    method: ExtensionConnectionMethod;
+    path: string;
+    headers?: Record<string, string>;
+    body?: JsonValue;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+
+export declare interface ExtensionConnectionResponse<TBody = JsonValue> {
+    status: number;
+    headers: Record<string, string>;
+    body: TBody;
+}
+
+export declare interface ExtensionConnectionsApi {
+    request<TBody = JsonValue>(connectionId: string, input: ExtensionConnectionRequest): Promise<ExtensionConnectionResponse<TBody>>;
+    stream(connectionId: string, input: ExtensionConnectionRequest): AsyncIterable<ExtensionConnectionStreamEvent>;
+}
+
+export declare type ExtensionConnectionStreamEvent = {
+    type: "response";
+    status: number;
+    headers: Record<string, string>;
+} | {
+    type: "data";
+    data: Uint8Array;
+} | {
+    type: "end";
+};
+
+export declare interface ExtensionContextBase<TSettings extends Record<string, unknown> = Record<string, unknown>> {
+    projectId: string;
+    /** Host workspace id when the command runs from inside a worktree-backed workspace. */
+    workspaceId?: string;
+    project: ExtensionProjectContext;
+    extensionId: string;
+    /** Extension package name. Used for grouping/prefixing user-facing references. */
+    name: string;
+    repo?: RepoContext;
+    source?: CommandSource;
+    storage: ExtensionStorageApi;
+    artifacts: ExtensionArtifactApi;
+    /** Working tree of the invocation's repo, scoped to its root. Absent for non-repo (event/hook) invocations. */
+    repoFiles?: ArtifactMount;
+    /** Files of the workspace this context targets, scoped to its working dir. */
+    workspaceFiles?: WorkspaceFilesMount;
+    /** Read-only files packaged with the installed extension, scoped to its package root. */
+    packageFiles: ExtensionPackageFilesApi;
+    /** Repo directory allocated to this extension. Present wherever repoFiles is present. */
+    extensionFiles?: ArtifactMount;
+    files: ExtensionFilesApi;
+    /** Project skill catalog. Present where the host wires it (command/event contexts). */
+    skills?: ExtensionSkillsApi;
+    sessions: ExtensionSessionsApi;
+    workspaces: ExtensionWorkspacesApi;
+    repos: ExtensionReposApi;
+    commands: CommandHelpersApi;
+    events: ExtensionEventsApi;
+    activity: ExtensionActivityApi;
+    notify: ExtensionNotifyApi;
+    process: ExtensionProcessApi;
+    /** Interactive PTY sessions. Present only where the host wires a terminal supervisor (e.g. the workbench panel). */
+    terminal?: ExtensionTerminalApi;
+    net: ExtensionNetApi;
+    connections: ExtensionConnectionsApi;
+    logger: ExtensionLoggerApi;
+    settings: ExtensionSettingsApi<TSettings>;
+}
+
+/**
+ * The full shape of an extension's contributions module. Identity (id, name, version,
+ * description, etc.) lives in `package.json`; `defineExtension` only accepts
+ * contribution surfaces.
+ */
+export declare interface ExtensionDefinition extends UiContributions, BehaviourContributions, AssetContributions, ProviderContributions {
+    settings?: ExtensionSettingsContribution;
+}
+
+export declare interface ExtensionEventsApi {
+    emit<TPayload extends Struct>(event: EventRef<TPayload> | string, payload: TPayload): Promise<EventDeliveryResult>;
+}
+
+export declare interface ExtensionFilesApi {
+    readText(fileId: string): Promise<string>;
+    writeText(fileId: string, value: string): Promise<void>;
+    createText(input: {
+        name: string;
+        content: string;
+        metadata?: JsonObject;
+    }): Promise<{
+        id: string;
+    }>;
+    delete(fileId: string): Promise<void>;
+}
+
+export declare interface ExtensionHarnessInput {
+    harnessId: string;
+    model?: string;
+}
+
+export declare type ExtensionLoadScope = "user" | "repo";
+
+export declare interface ExtensionLoggerApi {
+    info(message: string, metadata?: JsonObject): void;
+    warn(message: string, metadata?: JsonObject): void;
+    error(message: string, metadata?: JsonObject): void;
+}
+
+export declare interface ExtensionNetApi {
+    findFreePort(input?: {
+        host?: string;
+    }): Promise<number>;
+}
+
+export declare interface ExtensionNotifyApi {
+    toast(notice: CommandNotice): Promise<void>;
+    action(input: Omit<CreateNotificationInput, "projectId">): Promise<Notification_2>;
+    resolve(input: {
+        id?: string;
+        dedupeKey?: string;
+        status?: Extract<NotificationStatus, "done" | "dismissed" | "expired">;
+    }): Promise<Notification_2[]>;
+    dismiss(input: {
+        id?: string;
+        dedupeKey?: string;
+    }): Promise<Notification_2[]>;
+}
+
+declare interface ExtensionOwner {
+    publisher: string;
+    name: string;
+}
+
+export declare type ExtensionPackageFilesApi = Pick<ArtifactMount, "exists" | "readText" | "readBytes" | "list" | "listDirs">;
+
+export declare type ExtensionPanelRegion = (typeof extensionPanelRegions)[number];
+
+export declare const extensionPanelRegions: readonly ["main", "secondary", "side"];
+
+export declare interface ExtensionProcessApi {
+    run(input: ProcessRunInput): Promise<ProcessRunResult>;
+    runOrThrow(input: ProcessRunInput): Promise<ProcessRunResult>;
+    spawnDetached(input: {
+        command: string[];
+        cwd?: string;
+        env?: Record<string, string>;
+    }): Promise<{
+        pid?: number;
+    }>;
+}
+
+export declare interface ExtensionProjectContext {
+    id: string;
+    name: string;
+    shorthand: string;
+}
+
+export declare interface ExtensionReposApi {
+    list(): Promise<RepoContext[]>;
+    get(repoId: string): Promise<RepoContext>;
+    getDefault(): Promise<RepoContext | undefined>;
+    resolvePath(repoId: string, relativePath: string, options?: {
+        basePath?: string;
+    }): Promise<string>;
+}
+
+export declare interface ExtensionSessionResource {
+    type: "session";
+    id: string;
+    title: string;
+    status: SessionStatus;
+}
+
+export declare interface ExtensionSessionsApi {
+    get(id: string): Promise<{
+        id: string;
+        title: string;
+        status?: string;
+        original_session_id?: string | null;
+        cwd?: string | null;
+        updated_at?: string | null;
+        anchors_json?: ResourceAnchor[];
+    } | null>;
+    list(): Promise<Array<{
+        id: string;
+        title: string;
+        status: SessionStatus;
+        last_request_started?: string | null;
+        last_request_ended?: string | null;
+        updated_at?: string | null;
+        anchors_json?: ResourceAnchor[];
+    }>>;
+    /** Sessions linked to a workspace (via the workspace-session join), oldest first. */
+    listByWorkspace(workspaceId: string): Promise<Array<{
+        id: string;
+        title: string;
+        status: SessionStatus;
+        created_at?: string | null;
+        updated_at?: string | null;
+        anchors_json?: ResourceAnchor[];
+    }>>;
+    create(input: {
+        title: string;
+        prompt?: string;
+        harness?: ExtensionHarnessInput;
+        workspaceId?: string;
+        repoId?: string;
+        anchors?: ResourceAnchor[];
+        attachments?: SessionAttachmentRef[];
+        originalSessionId?: string;
+    }): Promise<ExtensionSessionResource>;
+    followup(input: {
+        sessionId: string;
+        prompt?: string;
+        attachments?: SessionAttachmentRef[];
+    }): Promise<void>;
+    addAnchors(sessionId: string, anchors: ResourceAnchor[]): Promise<void>;
+}
+
+export declare type ExtensionSettingProperty<TType extends ExtensionSettingValueType = ExtensionSettingValueType> = {
+    [TSettingType in TType]: {
+        type: TSettingType;
+        scope: ExtensionSettingScope;
+        default?: ExtensionSettingValueForType<TSettingType>;
+        enum?: ExtensionSettingValueForType<TSettingType>[];
+        title?: Localizable<string>;
+        description?: Localizable<string>;
+    };
+}[TType];
+
+export declare interface ExtensionSettingsApi<TSettings extends Record<string, unknown> = Record<string, unknown>> {
+    all(): Promise<Partial<TSettings>>;
+    get<TKey extends keyof TSettings & string>(key: TKey): Promise<TSettings[TKey] | undefined>;
+    set<TKey extends keyof TSettings & string>(key: TKey, value: TSettings[TKey]): Promise<void>;
+    delete<TKey extends keyof TSettings & string>(key: TKey): Promise<void>;
+}
+
+export declare interface ExtensionSettingsContribution<TProperties extends Record<string, ExtensionSettingProperty> = Record<string, ExtensionSettingProperty>> {
+    properties: TProperties;
+}
+
+export declare type ExtensionSettingScope = "global" | "project";
+
+export declare type ExtensionSettingValueForType<TType extends ExtensionSettingValueType> = TType extends "boolean" ? boolean : TType extends "number" ? number : TType extends "string" ? string : TType extends "array" ? JsonValue[] : JsonObject;
+
+export declare type ExtensionSettingValueType = "boolean" | "number" | "string" | "array" | "object";
+
+export declare interface ExtensionSkillsApi {
+    /** The project's resolved skill catalog (DB skills + extension-contributed skills, deduped). */
+    list(): Promise<Skill[]>;
+}
+
+export declare type ExtensionSourceKind = "local_path" | "git" | "registry";
+
+export declare interface ExtensionStorageApi {
+    scope(scope: StorageScope): ExtensionStorageApi;
+    files: ExtensionBlobsApi;
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    set<T = unknown>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    collection<TItem = unknown>(name: string): ExtensionStorageCollectionApi<TItem>;
+}
+
+export declare interface ExtensionStorageCollectionApi<TItem = unknown> {
+    get(id: string): Promise<TItem | undefined>;
+    list(): Promise<TItem[]>;
+    put(id: string, value: TItem): Promise<void>;
+    createIfAbsent(id: string, value: TItem): Promise<boolean>;
+    deleteIfValue(id: string, value: TItem): Promise<boolean>;
+    create(value: TItem): Promise<TItem & {
+        id: string;
+    }>;
+    delete(id: string): Promise<void>;
+    attachments(itemId: string): ExtensionBlobsApi;
+}
+
+/** Opens long-lived, interactive PTY sessions. Complements {@link ExtensionProcessApi}'s run-to-completion model. */
+export declare interface ExtensionTerminalApi {
+    openSession(request: TerminalSessionRequest): TerminalSessionHandle;
+}
+
+export declare type ExtensionViewModule<TProps = unknown> = {
+    mount: (mount: HTMLElement, host: GuestHost, propsStore: PropsStore<TProps>) => Promise<() => void> | (() => void) | void;
+};
+
+export declare type ExtensionViewRender<TProps = unknown> = (context: ExtensionViewRenderContext<TProps>) => void | (() => void) | Promise<void | (() => void)>;
+
+export declare type ExtensionViewRenderContext<TProps = unknown> = {
+    mount: HTMLElement;
+    host: GuestHost;
+    files: WebviewFilesClient;
+    propsStore: PropsStore<TProps>;
+    locale: string;
+    t: (key: string, defaultValue?: string, args?: Record<string, unknown>) => string;
+};
+
+export declare interface ExtensionWorkspace {
+    id: string;
+    name?: string;
+    project_id?: string;
+    workspace_shorthand?: string;
+    branch?: string | null;
+    worktree_path?: string | null;
+    provider_id?: string;
+    provider_state?: WorkspaceProviderState;
+    execution_kind?: "local" | "remote";
+    display_path?: string | null;
+    provider_capabilities_json?: WorkspaceCapabilities;
+    anchors_json?: ResourceAnchor[];
+    initializing?: boolean;
+    created_at?: string;
+    updated_at?: string;
+}
+
+export declare interface ExtensionWorkspacesApi {
+    list(): Promise<ExtensionWorkspace[]>;
+    get(id: string): Promise<ExtensionWorkspace | null>;
+    getByShorthand(shorthand: string): Promise<ExtensionWorkspace | null>;
+    create(input: CreateExtensionWorkspaceInput): Promise<ExtensionWorkspace>;
+    resolve(id: string): Promise<WorkspaceProviderResult>;
+    cancel(id: string): Promise<ExtensionWorkspace>;
+    archive(id: string): Promise<ExtensionWorkspace>;
+    removeWorktree(id: string): Promise<{
+        removed: boolean;
+    }>;
+    delete(id: string): Promise<void>;
+}
+
+declare interface ExternalRefInput {
+    extensionId: string;
+    id: string;
+}
+
+export declare interface FileIconThemeContribution extends ContributionDefinition<"file-icon-theme"> {
+    title: Localizable<string>;
+    source: PackageAssetDescriptor;
+    format: "vscode-file-icon-theme";
+    description?: Localizable<string>;
+}
+
+export declare type FilePart = {
+    type: "file";
+    fileId?: string;
+    mediaType?: string;
+    filename?: string;
+    size?: number;
+    url: string;
+};
+
+export declare interface FileRendererContribution extends RendererContributionBase {
+    load: RendererCallback<FileRendererLoadParams, FileRendererLoadResult>;
+    save?: RendererCallback<FileRendererSaveParams, unknown>;
+}
+
+export declare interface FileRendererLoadParams {
+    renderer: RendererContext;
+}
+
+export declare interface FileRendererLoadResult {
+    fileName?: string;
+    mimeType?: string;
+    content?: string;
+    dataUrl?: string;
+    placeholder?: string;
+    /** Override contribution-level save support for one loaded file. */
+    editable?: boolean;
+    /** Request Monaco for text that automatic dispatch would open as markdown. */
+    textRenderer?: "automatic" | "monaco";
+    /** Represent a deliberate no-file selection without an editable blank document. */
+    emptyState?: {
+        title: string;
+        description?: string;
+    };
+}
+
+export declare type FileRendererResourceRef = ResourceRef;
+
+export declare interface FileRendererSaveParams {
+    renderer: RendererContext;
+    content: string;
+}
+
+export declare interface FileRendererSectionAnchor {
+    /** Stable extension-owned tree node id. */
+    id: string;
+    /** Plain heading text as it appears in the Markdown document. */
+    heading: string;
+    /** Zero-based occurrence when the document repeats the same heading text. */
+    occurrence?: number;
+}
+
+export declare interface FileRendererSectionTarget {
+    /** The document outline used for deep-linking and active-heading sync. */
+    anchors: FileRendererSectionAnchor[];
+}
+
+export declare type FilesParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<string[], TRequired> & {
+    type: "files";
+    multiple?: boolean;
+    /** Passed through to the picker, e.g. "image/*". */
+    accept?: string;
+};
+
+export declare type FileViewBody = NativeViewBody<"file", FileRendererContribution>;
+
+export declare const gitEvents: {
+    committed: EventRef<CommitPayload>;
+    rebased: EventRef<RebasePayload>;
+    merged: EventRef<MergePayload>;
+    conflicted: EventRef<ConflictPayload>;
+};
+
+export declare interface GuestHost {
+    call<Capability extends WebviewHostCapability, const Params extends WebviewHostCapabilityParams[Capability] = WebviewHostCapabilityParams[Capability]>(method: Capability, ...args: {} extends WebviewHostCapabilityParams[Capability] ? [params?: Params] : [params: Params]): Promise<WebviewHostCapabilityResult<Capability, Params>>;
+    onEvent(scope: string, handler: (payload: unknown) => void): () => void;
+    /** The extension that owns this webview. */
+    extensionId?: string;
+}
+
+export declare type HarnessApprovalChannel = {
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResponse>;
+};
+
+export declare type HarnessAttachment = {
+    fileId: string;
+    fileName: string;
+    mimeType: string | null;
+    sizeBytes: number;
+    localPath: string;
+    url: string;
+};
+
+/**
+ * Host context a harness runs against. A structural subset of ExtensionContextBase,
+ * so richer host APIs can be passed without a contract change.
+ */
+export declare interface HarnessContext {
+    /** Present when the harness runs on behalf of a project session. */
+    projectId?: string;
+    extensionId: string;
+    /** Extension package name. */
+    name: string;
+    process: ExtensionProcessApi;
+    net: ExtensionNetApi;
+    connections: ExtensionConnectionsApi;
+    logger: ExtensionLoggerApi;
+    state: HarnessStateApi;
+}
+
+export declare interface HarnessDetectionResult {
+    available: boolean;
+    version?: string;
+    reason?: string;
+}
+
+export declare type HarnessEventSink = {
+    push(patch: JsonPatch): void;
+};
+
+export declare type HarnessExit = {
+    status: HarnessExitStatus;
+};
+
+export declare type HarnessExitStatus = "completed" | "failed" | "cancelled" | "disconnected";
+
+export declare type HarnessMessagesInput = {
+    agentSessionId: string;
+    cwd?: string;
+    workspace?: HarnessWorkspaceContext;
+};
+
+export declare type HarnessParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<{
+    harnessId: string;
+    model?: string;
+    params?: Record<string, string | boolean>;
+}, TRequired> & {
+    type: "harness";
+};
+
+export declare type HarnessParamDescriptor = SelectParam | BooleanParam;
+
+export declare type HarnessParams = Record<string, HarnessParamValue>;
+
+export declare type HarnessParamsSchema = Record<string, HarnessParamDescriptor>;
+
+export declare type HarnessParamValue = string | boolean;
+
+/**
+ * An agent harness contributed by an extension. The host injects the event sink
+ * (and approval channel) and owns the session lifecycle: timeouts, persistence,
+ * and status transitions are keyed off the returned HarnessSession.
+ */
+export declare interface HarnessProvider extends ContributionDefinition<"harness"> {
+    label: Localizable<string>;
+    /** Declares skill directories so the host installs project skills for this agent. Absent = no skill setup. */
+    skills?: HarnessSkillsLayout;
+    /** Discrete run params the host can render, persist as defaults, validate, and pass to start/resume. */
+    params?: HarnessParamsSchema;
+    /** Defaults to required. Optional harnesses can run against remote workspace execution targets. */
+    cwdRequirement?: "required" | "optional";
+    capabilities(ctx: HarnessContext): MaybePromise<AgentCapability[]>;
+    detect?(ctx: HarnessContext): MaybePromise<HarnessDetectionResult>;
+    listModels?(ctx: HarnessContext): MaybePromise<AgentModel[]>;
+    start(ctx: HarnessContext, input: HarnessStartInput): MaybePromise<HarnessSession>;
+    resume(ctx: HarnessContext, input: HarnessResumeInput): MaybePromise<HarnessSession>;
+    /** Re-bind after a host restart. Throw a `RetryableHarnessReattachError` only when another attempt may succeed. */
+    reattach?(ctx: HarnessContext, input: HarnessReattachInput): MaybePromise<HarnessSession>;
+    getMessages?(ctx: HarnessContext, input: HarnessMessagesInput): MaybePromise<SessionMessage[]>;
+}
+
+export declare type HarnessReattachInput = {
+    sessionId: string;
+    agentSessionId: string;
+    cwd?: string;
+    workspace?: HarnessWorkspaceContext;
+    events: HarnessEventSink;
+    /** Aborted when the host stops orphan recovery, including during shutdown. */
+    signal?: AbortSignal;
+};
+
+export declare type HarnessResumeInput = HarnessStartInput & {
+    agentSessionId: string;
+    /** Index offset so resumed streams align message patches with existing history. */
+    messageOffset?: number;
+    questionResponse?: QuestionResponse;
+    approvals?: HarnessApprovalChannel;
+};
+
+export declare type HarnessSession = {
+    /** Provider-side session id, used to resume/reattach later. */
+    agentSessionId?: string;
+    /** Settles exactly once; the host keys status transitions and persistence off it. */
+    done: Promise<HarnessExit>;
+    /** Called by the host on cancel or on its own activity timeout. */
+    stop(): void | Promise<void>;
+    timeoutStrategy?: TimeoutStrategy;
+    /** Observability only. */
+    pid?: number;
+};
+
+/** Where the harness's agent discovers skills. Paths are relative to the repo (dir) and home (globalDir). */
+export declare interface HarnessSkillsLayout {
+    dir: string;
+    /** Defaults to `dir` when omitted. */
+    globalDir?: string;
+}
+
+export declare type HarnessStartInput = {
+    prompt: string;
+    /** Host session id (correlation / env injection). */
+    sessionId: string;
+    cwd?: string;
+    workspace?: HarnessWorkspaceContext;
+    model?: string | null;
+    params?: HarnessParams;
+    attachments?: HarnessAttachment[];
+    events: HarnessEventSink;
+    /** Aborted when the host cancels the request that started or resumed this session. */
+    signal?: AbortSignal;
+};
+
+export declare interface HarnessStateApi {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    set<T = unknown>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+
+declare type HarnessWorkspaceContext = {
+    workspaceId: string;
+    executionTarget: WorkspaceExecutionTarget;
+};
+
+/**
+ * A handler for an event.
+ */
+export declare interface HookDefinition<TPayload extends Struct = Struct> extends ContributionDefinition<"hook"> {
+    event: EventRef<TPayload>;
+    run(ctx: EventContext, payload: TPayload): MaybePromise<void>;
+}
+
+export declare const isLocalizedString: (value: unknown) => value is LocalizedString;
+
+export declare const isValidLocalContributionId: (id: string) => boolean;
+
+export declare type JsonObject = {
+    [key: string]: JsonValue;
+};
+
+export declare type JsonParam<T = unknown, TRequired extends boolean | undefined = boolean | undefined> = ParamBase<T, TRequired> & {
+    type: "json";
+};
+
+export declare type JsonPatch = {
+    op: "add" | "replace" | "remove";
+    path: string;
+    value?: unknown;
+};
+
+export declare type JsonPrimitive = string | number | boolean | null;
+
+export declare type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+
+export declare interface KanbanRendererAttributeDescriptor {
+    id: string;
+    label: Localizable<string>;
+    type: KanbanRendererAttributeType;
+    filterable?: boolean;
+    groupable?: boolean;
+    sortable?: boolean;
+    displayable?: boolean;
+    editable?: boolean;
+    display?: KanbanRendererAttributeDisplay;
+}
+
+export declare type KanbanRendererAttributeDisplay = {
+    kind: "badge-list";
+    itemsAttributeId: string;
+};
+
+export declare type KanbanRendererAttributeType = {
+    kind: "enum";
+    options: KanbanRendererEnumOption[];
+} | {
+    kind: "enum-multi";
+    options: KanbanRendererEnumOption[];
+} | {
+    kind: "status";
+    statuses: StatusRef;
+} | {
+    kind: "string";
+} | {
+    kind: "date";
+} | {
+    kind: "number";
+} | {
+    kind: "user";
+};
+
+export declare interface KanbanRendererBoardColumnConfig {
+    color?: string;
+    canDragIn?: boolean;
+    canDragOut?: boolean;
+    canCreate?: boolean;
+    actions?: KanbanRendererColumnAction[];
+}
+
+export declare interface KanbanRendererColumnAction {
+    id: string;
+    label: Localizable<string>;
+    icon?: string;
+}
+
+export declare interface KanbanRendererContribution extends RendererContributionBase {
+    attributes?: KanbanRendererAttributeDescriptor[];
+    query: RendererCallback<KanbanRendererQueryParams, KanbanRendererQueryResult>;
+    onAttributeChange?: RendererCallback<{
+        rowId: string;
+        attributeId: string;
+        value: unknown;
+    }, unknown>;
+    onReorder?: RendererCallback<{
+        rowId: string;
+        beforeRowId?: string;
+    }, unknown>;
+    onColumnAction?: RendererCallback<{
+        columnId: string;
+        actionId: string;
+    }, unknown>;
+    createRow?: KanbanRendererCreateRowContribution;
+    rowActions?: KanbanRendererRowAction[];
+    onRowActivate?: KanbanRendererRowActivationHandler;
+    defaultSettings?: Partial<KanbanRendererSettings>;
+    defaultFilters?: KanbanRendererFilterState;
+    defaultViews?: KanbanRendererSavedView[];
+    defaultActiveViewId?: string;
+    hideToolbar?: boolean;
+}
+
+export declare interface KanbanRendererCreateRowContribution<TParams extends ParamObjectSchema = ParamObjectSchema> {
+    command: CommandRef<Struct, unknown>;
+    title?: Localizable<string>;
+    submitLabel?: Localizable<string>;
+    columnParam?: string;
+    params?: TParams;
+    attributesParam?: string;
+    attachments?: {
+        command: CommandRef<Struct, unknown>;
+        resourceParam: string;
+        fileParam: string;
+    };
+    labels?: {
+        cancel?: Localizable<string>;
+        properties?: Localizable<string>;
+        submitError?: Localizable<string>;
+        removeFile?: Localizable<string>;
+    };
+}
+
+export declare interface KanbanRendererEnumOption {
+    value: string;
+    label: Localizable<string>;
+    color?: string;
+    icon?: string | null;
+}
+
+export declare type KanbanRendererFilterState = Record<string, string[]>;
+
+export declare interface KanbanRendererQueryParams {
+    renderer: RendererContext;
+    settings: KanbanRendererSettings;
+    filters: KanbanRendererFilterState;
+}
+
+export declare interface KanbanRendererQueryResult {
+    rows: KanbanRendererRow[];
+    attributes?: KanbanRendererAttributeDescriptor[];
+    boardColumnConfigs?: Record<string, KanbanRendererBoardColumnConfig>;
+}
+
+export declare type KanbanRendererResourceRef = ResourceRef;
+
+export declare interface KanbanRendererRow {
+    id: string;
+    title: string;
+    resource?: KanbanRendererResourceRef;
+    attributes: Record<string, unknown>;
+}
+
+export declare interface KanbanRendererRowAction<TParams extends Struct = Struct> {
+    id: string;
+    label: Localizable<string>;
+    icon?: string;
+    command: CommandRef<TParams, unknown>;
+    destructive?: boolean;
+}
+
+export declare type KanbanRendererRowActivationHandler = RendererCallback<{
+    row: KanbanRendererRow;
+}, undefined | NavigationTarget>;
+
+export declare interface KanbanRendererSavedView {
+    id: string;
+    title: Localizable<string>;
+    settings: KanbanRendererSettings;
+    filters: KanbanRendererFilterState;
+    isDefault?: boolean;
+}
+
+export declare interface KanbanRendererSettings {
+    viewMode: KanbanRendererViewMode;
+    columnGrouping: string;
+    rowGrouping: string;
+    ordering: {
+        attributeId: string;
+        direction: KanbanRendererSortDirection;
+    };
+    displayProperties: string[];
+}
+
+export declare type KanbanRendererSortDirection = "asc" | "desc";
+
+export declare type KanbanRendererViewMode = "board" | "list";
+
+export declare type KanbanViewBody = NativeViewBody<"kanban", KanbanRendererContribution>;
+
+/**
+ * Chord string in TanStack Hotkeys syntax (e.g. "mod+shift+p"). `mod` is
+ * Cmd on macOS and Ctrl elsewhere. Parsing, validation, canonicalization,
+ * and display labels are all delegated to `@tanstack/hotkeys`.
+ */
+export declare type KeybindingChord = string;
+
+export declare interface KeybindingContribution extends ContributionDefinition<"keybinding"> {
+    /** Default chord. Used on every platform unless an override is provided. */
+    key: KeybindingChord;
+    /** macOS override. */
+    mac?: KeybindingChord;
+    /** Linux override. */
+    linux?: KeybindingChord;
+    /** Windows override. */
+    win?: KeybindingChord;
+    /** Action this chord executes through the shared navigation executor. */
+    action: NavigationTarget;
+    /** Optional gating predicate. The host evaluates it at dispatch time. */
+    when?: WhenExpression;
+}
+
+export declare const l10n: (key: string, defaultValue?: string) => {
+    default?: string | undefined;
+    $l10n: string;
+};
+
+export declare interface ListNotificationsQuery {
+    status?: NotificationStatus | NotificationStatus[];
+    priority?: NotificationPriority | NotificationPriority[];
+    sourceExtensionId?: string;
+    resourceType?: string;
+    resourceId?: string;
+    cursor?: string;
+    limit?: number;
+}
+
+export declare interface ListNotificationsResponse {
+    items: Notification_2[];
+    nextCursor?: string | null;
+}
+
+export declare type ListParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<string[], TRequired> & {
+    type: "list";
+};
+
+export declare type LoadingPart = {
+    type: "loading";
+};
+
+export declare const localContributionIdGrammar = "lowercase kebab-case segments separated by dots, such as \"ticket-status.create\"";
+
+export declare const localContributionIdPattern: RegExp;
+
+export declare interface LocalExtensionSource {
+    name: string;
+    path: string;
+    origin?: string;
+    installedAt: string;
+    updatedAt: string;
+}
+
+export declare type Localizable<T extends string = string> = T | LocalizedString;
+
+export declare interface LocalizedString {
+    readonly $l10n: string;
+    readonly default?: string;
+}
+
+export declare type LongTextParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<string, TRequired> & {
+    type: "longtext";
+};
+
+export declare interface MarkdownControl extends BaseControl {
+    type: "markdown";
+    defaultValue: string;
+    placeholder?: string;
+}
+
+export declare type MarkdownParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<string, TRequired> & {
+    type: "markdown";
+    placeholder?: Localizable<string>;
+};
+
+/**
+ * Resource-scoped visibility for command-palette contributions. Both the workbench host and the
+ * dashboard palette gate the same way, so the rule lives here once instead of being re-derived per
+ * surface. Only `resourceType` is evaluated: it is the sole `when` field a palette surface can
+ * resolve from the active resource alone (`mode`/`source`/`metadata` require execution context the
+ * palette does not have).
+ */
+export declare const matchesResourceWhen: (when: Pick<WhenExpression, "resourceType"> | {
+    resourceType?: readonly string[];
+} | undefined, resourceType: string | undefined) => boolean;
+
+export declare type MaybePromise<T> = T | Promise<T>;
+
+export declare interface MenuContribution<TSlotContext extends Struct = Struct, TParams extends Struct = Struct> {
+    slot: SlotRef<TSlotContext, "menu">;
+    label?: Localizable<string>;
+    group?: string;
+    placement?: "first" | "default" | "last";
+    icon?: string;
+    when?: WhenExpression;
+    params?: Partial<TParams>;
+    presentation?: "menu-item" | "button" | "icon-button";
+}
+
+export declare interface MergePayload extends CommitPayload {
+}
+
+/**
+ * Middleware that runs before a command.
+ */
+export declare interface MiddlewareDefinition<TParams extends Struct = Struct, TResult = unknown> extends ContributionDefinition<"middleware"> {
+    command: CommandRef<TParams, TResult>;
+    run: CommandMiddlewareHandler<TParams>;
+}
+
+export declare type MigrationContext = ExtensionContextBase;
+
+export declare interface ModeContribution extends ContributionDefinition<"mode"> {
+    label: Localizable<string>;
+    icon?: string;
+    regions: readonly ExtensionPanelRegion[];
+    /** Default theme for this mode. An explicit user choice for the mode takes precedence. */
+    defaultTheme?: ThemeRef;
+    /** Whether side panels may float while this mode is active. Defaults to visible. */
+    floatingPanels?: "visible" | "hidden";
+    /** Replace host chrome with a view, or hide it with false, while the mode is active. */
+    chrome?: Partial<Record<"nav" | "sidenav" | "activity" | "status", ViewRef | false>>;
+    /** Region-level layout policy. The mode owns it; placements cannot set it. */
+    regionSettings?: Readonly<Partial<Record<DockedWorkbenchRegion, ModeRegionSettings>>>;
+}
+
+declare type ModeDefinition = Omit<ModeContribution, "ref">;
+
+export declare type ModeRef = ContributionRef<"mode">;
+
+export declare interface ModeRegionSettings {
+    /** Hide the panel header when the mode supplies its own controls. */
+    readonly showHeader?: boolean;
+    readonly size?: RegionSize;
+    /** Allow dragging this region closed. Explicit hide/show is always available. */
+    readonly collapsible?: boolean;
+    /** Keep a tab visible when this region has only one visible item. */
+    readonly alwaysShowTabs?: boolean;
+}
+
+export declare type MultiSelectParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<string[], TRequired> & {
+    type: "multi-select";
+    options: ParamOption[];
+};
+
+declare type NativeViewBody<Kind extends string, Definition> = {
+    readonly kind: Kind;
+} & Omit<Definition, "title" | "icon" | "resourceKind">;
+
+export declare interface NavigationItemContribution extends ContributionDefinition<"navigation-item"> {
+    readonly owner: NavigationOwnerRef;
+    readonly slot?: NavigationTreeSlot;
+    readonly label: Localizable<string>;
+    readonly icon?: string;
+    readonly group?: string;
+    readonly when?: WhenExpression;
+    readonly action: NavigationTarget;
+}
+
+declare type NavigationItemDefinition = Omit<NavigationItemContribution, "ref">;
+
+export declare type NavigationOwnerRef = ModeRef | PageRef;
+
+export declare type NavigationTarget = NavigationTargetItem | NavigationTargetCompound;
+
+export declare interface NavigationTargetCommand {
+    kind: "command";
+    target: CommandTarget<JsonObject>;
+}
+
+export declare interface NavigationTargetCompound {
+    kind: "compound";
+    targets: readonly (NavigationTargetPage | NavigationTargetPanel)[];
+}
+
+export declare interface NavigationTargetHref {
+    kind: "href";
+    href: string;
+}
+
+export declare type NavigationTargetItem = NavigationTargetPage | NavigationTargetPanel | NavigationTargetCommand | NavigationTargetHref;
+
+export declare interface NavigationTargetPage {
+    kind: "page";
+    page: PageRef;
+    resource?: ResourceRef;
+    section?: FileRendererSectionTarget;
+    open?: PageOpenIntent;
+    parent?: NavigationTargetPage;
+}
+
+export declare interface NavigationTargetPanel {
+    kind: "panel";
+    panel: PanelRef;
+    resource?: ResourceRef;
+    open?: PageOpenIntent;
+}
+
+export declare interface NavigationTreeContribution extends ContributionDefinition<"navigation-tree"> {
+    readonly owner: NavigationOwnerRef;
+    readonly slot?: NavigationTreeSlot;
+    readonly view: ViewRef;
+}
+
+declare type NavigationTreeDefinition = Omit<NavigationTreeContribution, "ref">;
+
+export declare type NavigationTreeSlot = "header" | "content" | "footer";
+
+declare type NoExtraFields<Definition, Contract> = Definition & ExactOptions<Definition, Contract>;
+
+declare type NoExtraFields_2<Definition, Contract> = Definition & Record<Exclude<keyof Definition, keyof Contract>, never>;
+
+declare interface Notification_2 {
+    id: string;
+    projectId: string;
+    title: string;
+    body?: string | null;
+    kind: NotificationKind;
+    status: NotificationStatus;
+    priority: NotificationPriority;
+    source: CommandSource;
+    origin: NotificationOrigin;
+    sourceExtensionId?: string | null;
+    actorType?: NotificationActorType | null;
+    actorId?: string | null;
+    target?: ResourceRef | null;
+    related: ResourceRef[];
+    actions: NotificationAction[];
+    dedupeKey?: string | null;
+    metadata?: JsonObject | null;
+    createdAt: string;
+    updatedAt: string;
+    readAt?: string | null;
+    resolvedAt?: string | null;
+    snoozedUntil?: string | null;
+    expiresAt?: string | null;
+}
+export { Notification_2 as Notification }
+
+export declare type NotificationAction = {
+    id: string;
+    label: string;
+    kind: "navigate";
+    target: NavigationTarget;
+    primary?: boolean;
+} | {
+    id: string;
+    label: string;
+    kind: "command";
+    command: string;
+    params?: JsonObject;
+    primary?: boolean;
+    destructive?: boolean;
+} | {
+    id: string;
+    label: string;
+    kind: "url";
+    href: string;
+    primary?: boolean;
+};
+
+export declare type NotificationActorType = "user" | "agent" | "system";
+
+export declare type NotificationKind = "needs_review" | "ready_to_merge" | "blocked" | "approval_required" | "failed" | "info";
+
+export declare type NotificationOrigin = "core" | "extension" | "agent";
+
+export declare type NotificationPriority = "low" | "normal" | "high" | "urgent";
+
+export declare type NotificationStatus = "open" | "read" | "snoozed" | "done" | "dismissed" | "expired";
+
+export declare interface NumberControl extends BaseControl {
+    type: "number";
+    defaultValue: number;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+
+export declare type NumberParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<number, TRequired> & {
+    type: "number";
+};
+
+declare type OptionalParamKeys<TSchema extends ParamObjectSchema> = Exclude<keyof TSchema, RequiredParamKeys<TSchema>>;
+
+/**
+ * Reference an asset shipped alongside the extension's compiled output. `path` is
+ * resolved relative to `baseUrl`; in practice authors always pass `import.meta.url`
+ * so the runtime can locate the file no matter where the extension is installed.
+ *
+ * @example
+ *   webview: { entry: packageAsset("./src/page.tsx", import.meta.url) }
+ */
+export declare const packageAsset: (path: string, baseUrl: string) => PackageAssetDescriptor;
+
+export declare interface PackageAssetDescriptor {
+    kind: "package-asset";
+    path: string;
+    baseUrl: string;
+}
+
+/** Validated panel of an extension's package.json identity fields. */
+export declare interface PackageManifest {
+    /** Extension package name. Matches `^[a-z][a-z0-9-]*$`. */
+    name: string;
+    /** Package version (semver). */
+    version: string;
+    /** Optional human-friendly name. Falls back to `name`. */
+    displayName?: string;
+    /** Optional package description. */
+    description?: string;
+    /** Publisher segment of the extension id. Matches `^[a-z][a-z0-9-]*$`. */
+    publisher: string;
+    /** Relative path to the contributions entry module. */
+    main: string;
+    /** Semver range checked against the host extension API version. */
+    enginesPstdio: string;
+    /** Prompt Studio-specific package metadata. */
+    pstdio?: {
+        /** Install/load scope. Defaults to "user" when omitted. */
+        scope?: ExtensionLoadScope;
+    };
+    /** Derived `${publisher}.${name}`. */
+    id: string;
+}
+
+export declare interface PageContribution extends ContributionDefinition<"page"> {
+    readonly title: Localizable<string>;
+    readonly icon?: string;
+    readonly path: string;
+    readonly mode: ModeRef;
+    readonly parent?: PageRef;
+    readonly resource?: ResourceConstraint;
+    readonly main: PageMain;
+    readonly slots: readonly PageSlot[];
+    readonly panels: Readonly<Record<string, PageSlotRef>>;
+}
+
+declare type PageDefinition = Omit<PageContribution, "ref" | "panels">;
+
+export declare interface PageLocation {
+    readonly page: PageRef;
+    readonly resource?: ResourceRef;
+    readonly section?: FileRendererSectionTarget;
+    readonly parent?: PageLocation;
+}
+
+export declare type PageMain = PageMainView | PageMainPanels;
+
+export declare interface PageMainPanels {
+    readonly kind: "panels";
+    readonly empty: ViewRef;
+}
+
+export declare interface PageMainView extends PlacementPresentation {
+    readonly kind: "view";
+    readonly view: ViewRef;
+    readonly cardinality: PageSlotCardinality;
+}
+
+export declare type PageOpenIntent = "preview" | "pin";
+
+declare type PagePanelRefs<Slots extends readonly PageSlot[]> = {
+    readonly [Id in Slots[number]["id"]]: PageSlotRef;
+};
+
+export declare type PageRef = ContributionRef<"page">;
+
+/** A page-owned panel. Main presentation and routed context belong to the page. */
+export declare interface PageSlot extends PlacementPresentation {
+    readonly id: string;
+    readonly region: PageSlotRegion;
+    readonly order?: number;
+    readonly item: PlacementItem;
+    readonly openOn?: "page-resource";
+}
+
+export declare type PageSlotCardinality = "one" | "many";
+
+export declare interface PageSlotRef {
+    readonly kind: "page-slot";
+    readonly page: PageRef;
+    readonly id: string;
+}
+
+export declare type PageSlotRegion = ExtensionPanelRegion;
+
+export declare type PageSlotRole = "primary" | "auxiliary";
+
+export declare type PanelRef = PlacementRef | PageSlotRef;
+
+declare type ParamBase<TValue, TRequired extends boolean | undefined = boolean | undefined> = {
+    label?: Localizable<string>;
+    description?: Localizable<string>;
+    defaultValue?: TValue;
+    metadata?: JsonObject;
+    resolvedFrom?: "resource";
+} & ParamRequired<TRequired>;
+
+export declare type ParamDescriptor<TValue = unknown, TRequired extends boolean | undefined = boolean | undefined> = TextParam<TRequired> | LongTextParam<TRequired> | MarkdownParam<TRequired> | NumberParam<TRequired> | BooleanParam<TRequired> | SelectParam<TRequired> | MultiSelectParam<TRequired> | FilesParam<TRequired> | RepoParam<TRequired> | HarnessParam<TRequired> | TemplateParam<TRequired> | ResourceParam<TRequired> | JsonParam<TValue, TRequired> | ListParam<TRequired>;
+
+export declare type ParamEditorReadOnlyContent = string | number | boolean | null | Array<string | number | boolean | null> | {
+    type: "image";
+    src: string;
+    alt: string;
+} | {
+    type: "image-gallery";
+    images: ParamEditorReadOnlyImage[];
+};
+
+export declare interface ParamEditorReadOnlyImage {
+    src: string;
+    alt: string;
+}
+
+export declare type ParamObjectSchema = Record<string, ParamDescriptor>;
+
+declare type ParamOption = {
+    label: string;
+    value: string;
+    icon?: string;
+};
+
+declare type ParamOptions<TParam extends {
+    type: string;
+}> = Omit<TParam, "type">;
+
+declare type ParamRequired<TRequired extends boolean | undefined> = TRequired extends true ? {
+    required: true;
+} : TRequired extends false ? {
+    required: false;
+} : {
+    required?: boolean;
+};
+
+/**
+ * Builders for typed parameter descriptors. Each builder produces a discriminated
+ * `ParamDescriptor` so the runtime and editor only see fields valid for that type.
+ *
+ * @example
+ *   params: {
+ *     amount: params.number({ defaultValue: 1 }),
+ *     mode: params.select({ options: [{ label: "Fast", value: "fast" }] }),
+ *   }
+ */
+export declare const params: {
+    text: <const TOptions extends ParamOptions<TextParam> | undefined = undefined>(options?: TOptions) => TextParam<RequiredOf<TOptions>>;
+    longText: <const TOptions extends ParamOptions<LongTextParam> | undefined = undefined>(options?: TOptions) => LongTextParam<RequiredOf<TOptions>>;
+    markdown: <const TOptions extends ParamOptions<MarkdownParam> | undefined = undefined>(options?: TOptions) => MarkdownParam<RequiredOf<TOptions>>;
+    files: <const TOptions extends ParamOptions<FilesParam> | undefined = undefined>(options?: TOptions) => FilesParam<RequiredOf<TOptions>>;
+    number: <const TOptions extends ParamOptions<NumberParam> | undefined = undefined>(options?: TOptions) => NumberParam<RequiredOf<TOptions>>;
+    boolean: <const TOptions extends ParamOptions<BooleanParam> | undefined = undefined>(options?: TOptions) => BooleanParam<RequiredOf<TOptions>>;
+    select: <const TOptions extends ParamOptions<SelectParam>>(options: TOptions) => SelectParam<RequiredOf<TOptions>>;
+    multiSelect: <const TOptions extends ParamOptions<MultiSelectParam>>(options: TOptions) => MultiSelectParam<RequiredOf<TOptions>>;
+    repo: <const TOptions extends ParamOptions<RepoParam> | undefined = undefined>(options?: TOptions) => RepoParam<RequiredOf<TOptions>>;
+    harness: <const TOptions extends ParamOptions<HarnessParam> | undefined = undefined>(options?: TOptions) => HarnessParam<RequiredOf<TOptions>>;
+    template: <const TOptions extends Omit<TemplateParam, "type" | "templateType"> & {
+        type: string;
+    }>(options: TOptions) => TemplateParam<RequiredOf<TOptions>>;
+    resource: <const TOptions extends ParamOptions<ResourceParam>>(options: TOptions) => ResourceParam<RequiredOf<TOptions>>;
+    json: <T = unknown, const TOptions extends ParamOptions<JsonParam<T>> | undefined = undefined>(options?: TOptions) => JsonParam<T, RequiredOf<TOptions>>;
+    list: <const TOptions extends ParamOptions<ListParam> | undefined = undefined>(options?: TOptions) => ListParam<RequiredOf<TOptions>>;
+};
+
+export declare type ParamsOf<TSchema extends ParamObjectSchema> = {
+    [K in RequiredParamKeys<TSchema>]: ParamValue<TSchema[K]>;
+} & {
+    [K in OptionalParamKeys<TSchema>]?: ParamValue<TSchema[K]>;
+};
+
+export declare type ParamType = "text" | "longtext" | "markdown" | "number" | "boolean" | "select" | "multi-select" | "files" | "repo" | "harness" | "template" | "resource" | "json" | "list";
+
+export declare type ParamValue<TDescriptor extends ParamDescriptor> = TDescriptor extends ParamDescriptor<infer V> ? V : never;
+
+export declare type PatchPart = {
+    type: "patch";
+    hash?: string;
+    files?: unknown;
+};
+
+export declare interface PlacementContribution extends ContributionDefinition<"placement">, PlacementPresentation {
+    readonly mode: ModeRef;
+    readonly item: PlacementItem;
+    readonly region: ExtensionPanelRegion;
+    readonly order?: number;
+    readonly movableTo?: readonly ExtensionPanelRegion[];
+}
+
+declare type PlacementDefinition = Omit<PlacementContribution, "ref">;
+
+export declare type PlacementIdentity = PlacementOwner & {
+    readonly instanceKey: string;
+};
+
+export declare type PlacementItem = {
+    readonly kind: "view";
+    readonly view: ViewRef;
+    readonly presence: PlacementPresence;
+} | {
+    readonly kind: "binding";
+    readonly binding: ResourceBinding;
+};
+
+export declare type PlacementMountStrategy = "active" | "keep-mounted";
+
+export declare type PlacementOwner = {
+    readonly kind: "shell";
+    readonly placementId: string;
+} | {
+    readonly kind: "mode";
+    readonly modeId: string;
+    readonly placementId: string;
+} | {
+    readonly kind: "page";
+    readonly pageId: string;
+    readonly slotId: string;
+};
+
+/**
+ * Initial presence of a static placement inside its owner scope.
+ * - "fixed": always open while the owner is active; the user cannot close it.
+ * - "open": open when the owner has no saved state; the user may close it.
+ * - "closed": closed until the user opens it (for example through the Add panel).
+ * A saved user choice wins over "open" and "closed" on the next visit.
+ */
+export declare type PlacementPresence = "fixed" | "open" | "closed";
+
+export declare interface PlacementPresentation {
+    readonly mountStrategy?: PlacementMountStrategy;
+    readonly hiddenByDefault?: boolean;
+    readonly headerBorderBottom?: boolean;
+    readonly tab?: PlacementTabPresentation;
+}
+
+export declare type PlacementRef = ContributionRef<"placement">;
+
+export declare interface PlacementTabMenuGroup {
+    readonly id: string;
+    readonly rows: readonly PlacementTabMenuRow[];
+}
+
+export declare interface PlacementTabMenuRow {
+    readonly id: string;
+    readonly label: Localizable<string>;
+    readonly icon?: string;
+    readonly iconColor?: string;
+    readonly selected?: boolean;
+    readonly disabled?: boolean;
+    readonly action?: NavigationTarget;
+}
+
+export declare interface PlacementTabPresentation {
+    readonly query: RendererCallback<JsonObject, PlacementTabSnapshot>;
+    readonly refreshEvents?: readonly RendererEventReference[];
+}
+
+export declare interface PlacementTabSnapshot extends Struct {
+    readonly label?: Localizable<string>;
+    readonly icon?: string;
+    readonly indicator?: {
+        readonly icon: string;
+        readonly color?: string;
+        readonly label?: Localizable<string>;
+    };
+    readonly menu?: readonly PlacementTabMenuGroup[];
+}
+
+export declare interface ProcessRunInput {
+    command: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+
+export declare interface ProcessRunResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+
+export declare const projectEvents: {
+    opened: EventRef<    {
+    projectId: string;
+    }>;
+};
+
+export declare const projectSlots: {
+    sidenav: SlotRef<object, "panel">;
+    headerPrimary: SlotRef<object, "menu">;
+    headerOverflow: SlotRef<object, "menu">;
+    settingsPanels: SlotRef<object, "settings">;
+};
+
+export declare type PropsStore<TProps = unknown> = {
+    get: () => TProps;
+    subscribe: (listener: (props: TProps) => void) => () => void;
+};
+
+/** Provider contributions: harnesses, workspace types. */
+export declare interface ProviderContributions {
+    connections?: readonly ExtensionConnectionContribution[];
+    workspaceTypes?: readonly WorkspaceTypeProvider[];
+    harnesses?: readonly HarnessProvider[];
+    resourceHierarchyProviders?: readonly ResourceHierarchyProvider[];
+}
+
+declare type QualifiableRef = ContributionRef<ContributionKind> | PageSlotRef;
+
+export declare type QualifiedRef<Ref extends QualifiableRef> = Ref extends PageSlotRef ? Omit<Ref, "page"> & {
+    readonly page: QualifiedRef<Ref["page"]>;
+} : Ref & {
+    readonly extensionId: string;
+};
+
+/** Publish a provider-owned reference without changing the local contribution definition. */
+export declare function qualifyRef<Ref extends QualifiableRef>(owner: string, ref: Ref): QualifiedRef<Ref>;
+
+export declare type QuestionResponse = {
+    answers: string[][];
+};
+
+/** Two-handle numeric range control. Values normalize to ordered `[start, end]`. */
+export declare interface RangeControl extends BaseControl {
+    type: "range";
+    defaultValue: RangeValue;
+    min: number;
+    max: number;
+    step?: number;
+    unit?: string;
+    markerCount?: number;
+}
+
+export declare type RangeValue = [number, number];
+
+/** Serializable display-only value rendered by the read-only Param Editor. */
+export declare interface ReadOnlyControl extends BaseControl {
+    type: "readOnly";
+    value: ParamEditorReadOnlyContent;
+}
+
+export declare type ReasoningPart = {
+    type: "reasoning";
+    text: string;
+};
+
+export declare interface RebasePayload {
+    projectId: string;
+    repoPath?: string;
+    worktreePath?: string;
+    branch?: string;
+    workspace?: ExtensionWorkspace;
+    anchors?: ResourceAnchor[];
+}
+
+export declare interface RegionSize {
+    readonly defaultPx?: number;
+    readonly minPx?: number;
+    readonly maxPx?: number;
+}
+
+export declare type RendererCallback<TInput extends Struct = Struct, TResult = unknown, TSettings extends Record<string, unknown> = Record<string, unknown>> = (ctx: ExtensionContextBase<TSettings>, input: TInput & {
+    renderer: RendererContext;
+}) => MaybePromise<TResult>;
+
+export declare interface RendererContext {
+    rendererId: string;
+    projectId?: string;
+    modeId?: string;
+    resource?: ResourceRef;
+    invocation?: RendererInvocationContext;
+}
+
+export declare interface RendererContributionBase {
+    title: Localizable<string>;
+    icon?: string;
+    resourceKind?: string;
+    refreshEvents?: readonly RendererEventReference[];
+    emptyTitle?: Localizable<string>;
+    emptyDescription?: Localizable<string>;
+}
+
+/** A raw cross-extension id must be namespaced. Local events use an EventRef. */
+export declare type RendererEventReference = EventRef | `${string}.${string}`;
+
+export declare interface RendererInvocationContext {
+    placement: "visible" | "background";
+}
+
+export declare interface RepoContext {
+    projectId: string;
+    repoId: string;
+    path: string;
+    remote?: string | null;
+    role?: "default" | "selected" | "workspace";
+}
+
+export declare type RepoParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<{
+    repoId: string;
+    branch?: string;
+}, TRequired> & {
+    type: "repo";
+};
+
+export declare interface RepoRef {
+    readonly id: string;
+}
+
+declare type RequiredOf<TOptions> = TOptions extends {
+    required: infer TRequired extends boolean;
+} ? TRequired : undefined;
+
+declare type RequiredPageParent<Definition extends PageDefinition> = Definition extends {
+    resource: unknown;
+    main: {
+        kind: "view";
+    };
+} ? {
+    readonly parent: PageRef;
+} : unknown;
+
+declare type RequiredPageResource<Definition extends PageDefinition> = Definition extends {
+    main: {
+        kind: "view";
+        cardinality: "many";
+    };
+} ? {
+    readonly resource: NonNullable<PageDefinition["resource"]>;
+} : unknown;
+
+declare type RequiredParamKeys<TSchema extends ParamObjectSchema> = {
+    [K in keyof TSchema]: TSchema[K] extends {
+        required: true;
+    } ? K : never;
+}[keyof TSchema];
+
+export declare interface ResourceAnchor extends ResourceRef {
+    role?: ResourceRole;
+}
+
+export declare interface ResourceBinding extends ResourceConstraint {
+    readonly view: ViewRef;
+    readonly cardinality: "one" | "many";
+    readonly add?: NavigationTarget;
+}
+
+export declare interface ResourceConstraint {
+    readonly kinds: readonly ResourceKindRef[];
+}
+
+/**
+ * Resource references rendered as tags/chips. View-only by default; set `editable`
+ * to pick from `options` via a dropdown. Value is the selected option id(s), mirroring
+ * {@link SelectionControl}, so it stays JSON-safe across the controls-command boundary.
+ */
+export declare interface ResourceControl extends BaseControl {
+    type: "resource";
+    defaultValue: string | string[];
+    options: ResourceOption[];
+    multiSelect?: boolean;
+    editable?: boolean;
+    placeholder?: string;
+    emptyText?: string;
+}
+
+export declare interface ResourceHierarchyProvider extends ContributionDefinition<"resource-hierarchy-provider"> {
+    resourceKind: ResourceKindRef;
+    parent(ctx: ExtensionContextBase, resource: ResourceRef): MaybePromise<ResourceRef | ViewHierarchyParent | null>;
+}
+
+/** Stable identity for selection and reuse; labels and metadata do not change identity. */
+export declare function resourceKey(resource: ResourceRef): string;
+
+export declare function resourceKey(resource: ResourceRef | undefined): string | undefined;
+
+export declare interface ResourceKindDefinition extends ContributionDefinition<"resource-kind"> {
+    readonly label?: Localizable<string>;
+    readonly icon?: string;
+    readonly menuSlots?: readonly ResourceMenuSlotDefinition[];
+}
+
+declare type ResourceKindDefinitionInput = Omit<ResourceKindDefinition, "ref">;
+
+export declare type ResourceKindRef = ContributionRef<"resource-kind">;
+
+export declare interface ResourceMenuSlotDefinition {
+    readonly id: string;
+    readonly placement: "header-primary" | "header-overflow" | "context-menu";
+    readonly label?: Localizable<string>;
+    readonly access: "owner" | "public";
+    readonly order?: number;
+}
+
+export declare const resourceMenuSlotRef: (resourceKind: ResourceKindRef, id: string) => SlotRef<object, "menu">;
+
+/**
+ * Serializable resource chip. Clicking it opens `href` externally, opens `ref` via
+ * `onOpenResource`, or copies `copyText` to the clipboard — whichever is set.
+ */
+export declare interface ResourceOption {
+    id: string;
+    name: string;
+    icon?: string;
+    color?: string;
+    description?: string;
+    href?: string;
+    ref?: ResourceRefValue;
+    copyText?: string;
+}
+
+export declare type ResourceParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<ResourceRef, TRequired> & {
+    type: "resource";
+    resourceType: string;
+};
+
+export declare interface ResourceRef {
+    type: string;
+    id: string;
+    projectId?: string;
+    label?: string;
+    icon?: string;
+    extensionId?: string;
+    metadata?: JsonObject;
+}
+
+/** A reference the host can open (e.g. another resource tab). */
+export declare type ResourceRefValue = ResourceRef;
+
+export declare type ResourceRole = "primary" | "context" | "source" | "result";
+
+/** A reattach error is permanent unless the provider explicitly marks it retryable. */
+export declare type RetryableHarnessReattachError = Error & {
+    readonly retryable: true;
+};
+
+export declare interface ScheduleContribution<TParams extends Struct = Struct> extends ContributionDefinition<"schedule"> {
+    title: Localizable<string>;
+    schedule: ScheduleExpression;
+    command: CommandRef<TParams, unknown>;
+    params?: TParams;
+    repo?: RepoRef;
+    disabled?: boolean;
+}
+
+export declare type ScheduleExpression = string;
+
+declare type SchemaParams<TSchema extends ParamObjectSchema | undefined> = TSchema extends ParamObjectSchema ? ParamsOf<TSchema> : Record<string, never>;
+
+/** Mutually-exclusive mode control rendered as a segmented button group. */
+export declare interface SegmentedControl extends BaseControl {
+    type: "segmented";
+    defaultValue: string;
+    options: SegmentedOption[];
+    variant?: "default" | "dots";
+}
+
+export declare interface SegmentedOption {
+    id: string;
+    name: string;
+    icon?: string;
+    indicatorColor?: string;
+}
+
+export declare interface SelectionControl extends BaseControl {
+    type: "selection";
+    defaultValue: string | string[];
+    options: SelectionOption[];
+    multiSelect?: boolean;
+    placeholder?: string;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    group?: SelectionGroup;
+    /** Adds a "clear" row so a single-select can be returned to unset. */
+    clearable?: boolean;
+    /**
+     * Renders the control inert but still as a control — unlike `readOnly`, which
+     * collapses it to plain text and drops the option's icon.
+     */
+    disabled?: boolean;
+}
+
+/** Parent selector used to swap the option set of a grouped selection. */
+export declare interface SelectionGroup {
+    id: string;
+    name: string;
+    defaultValue: string;
+    options: SelectionOption[];
+    placeholder?: string;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    disabled?: boolean;
+}
+
+export declare interface SelectionOption {
+    id: string;
+    name: string;
+    icon?: string;
+    /** Palette key (e.g. "blue") applied to the option's icon. */
+    color?: string;
+    description?: string;
+    disabled?: boolean;
+}
+
+export declare type SelectParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<string, TRequired> & {
+    type: "select";
+    options: ParamOption[];
+};
+
+export declare interface SerializedError {
+    name?: string;
+    message: string;
+    stack?: string;
+    cause?: JsonValue;
+}
+
+declare type SessionAttachmentRef = z.infer<typeof sessionAttachmentRefSchema>;
+
+declare const sessionAttachmentRefSchema: z.ZodObject<{
+    file_id: z.ZodString;
+}, z.core.$strip>;
+
+export declare const sessionEvents: {
+    started: EventRef<SessionLifecyclePayload & {
+    anchors?: ResourceAnchor[];
+    }>;
+    resumed: EventRef<SessionLifecyclePayload>;
+    awaitingInput: EventRef<SessionLifecyclePayload>;
+    succeeded: EventRef<SessionLifecyclePayload>;
+    failed: EventRef<SessionLifecyclePayload>;
+    completed: EventRef<SessionLifecyclePayload & {
+    anchors?: ResourceAnchor[];
+    }>;
+};
+
+export declare interface SessionLifecyclePayload {
+    projectId: string;
+    sessionId: string;
+    sessionStatus?: string;
+    originalSessionId?: string;
+    workspace?: ExtensionWorkspace;
+    workspaceId?: string;
+    worktreePath?: string;
+    branch?: string;
+    anchors?: ResourceAnchor[];
+}
+
+export declare type SessionMessage = {
+    id: string;
+    role: SessionMessageRole;
+    parts: SessionMessagePart[];
+    index?: number;
+    createdAt?: number;
+    modelId?: string;
+    providerId?: string;
+    tokens?: {
+        input?: number;
+        output?: number;
+        reasoning?: number;
+        cache?: {
+            read?: number;
+            write?: number;
+        };
+    };
+};
+
+export declare type SessionMessagePart = TextPart | ReasoningPart | ToolPart | StepStartPart | StepFinishPart | PatchPart | FilePart | LoadingPart | ErrorPart | TokenUsagePart;
+
+export declare type SessionMessageRole = "user" | "assistant" | "tool" | "system" | "developer";
+
+export declare const sessionSlots: {
+    headerPrimary: SlotRef<object, "menu">;
+    headerOverflow: SlotRef<object, "menu">;
+};
+
+declare type SessionStatus = z.infer<typeof sessionStatusSchema>;
+
+declare const sessionStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    in_progress: "in_progress";
+    awaiting_input: "awaiting_input";
+    queued: "queued";
+    cancelled: "cancelled";
+    disconnected: "disconnected";
+}>;
+
+declare type SettingsMap<TSettings> = TSettings extends {
+    properties: infer TProperties extends Record<string, ExtensionSettingProperty>;
+} ? {
+    [K in keyof TProperties & string]: SettingValue<TProperties[K]>;
+} : Record<string, never>;
+
+export declare interface SettingsPanelContribution extends ContributionDefinition<"settings-panel"> {
+    view: ViewRef;
+    slot: SettingsSlotRef;
+    section?: SettingsSectionRef;
+}
+
+/** A named group in the settings navigation that an extension's panels can sit under. */
+export declare interface SettingsSectionContribution extends ContributionDefinition<"settings-section"> {
+    title: Localizable<string>;
+    /** Lower sorts first among sibling sections. */
+    order?: number;
+}
+
+export declare type SettingsSectionRef = ContributionRef<"settings-section">;
+
+export declare interface SettingsSlotRef {
+    readonly id: string;
+}
+
+declare type SettingValue<TProperty> = TProperty extends {
+    type: "boolean";
+} ? boolean : TProperty extends {
+    type: "number";
+} ? number : TProperty extends {
+    type: "string";
+} ? string : TProperty extends {
+    type: "array";
+} ? unknown[] : TProperty extends {
+    type: "object";
+} ? Record<string, unknown> : unknown;
+
+export declare type SetupContext = ExtensionContextBase;
+
+declare type Skill = z.infer<typeof skillSchema>;
+
+export declare interface SkillContribution extends ContributionDefinition<"skill"> {
+    title: Localizable<string>;
+    source: PackageAssetDescriptor;
+    description?: Localizable<string>;
+}
+
+declare const skillSchema: z.ZodObject<{
+    id: z.ZodString;
+    project_id: z.ZodString;
+    name: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    source_kind: z.ZodEnum<{
+        project: "project";
+        extension: "extension";
+    }>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        encoding: z.ZodLiteral<"utf8">;
+    }, z.core.$strip>>;
+    editable: z.ZodBoolean;
+    extension_instance_id: z.ZodOptional<z.ZodString>;
+    extension_id: z.ZodOptional<z.ZodString>;
+    installed_extension_id: z.ZodOptional<z.ZodString>;
+    install_name: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"package-asset">;
+        path: z.ZodString;
+        baseUrl: z.ZodString;
+    }, z.core.$strip>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    deleted_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+
+export declare interface SlotInvocationContext<TContext extends Struct = Struct> {
+    id: string;
+    kind: UiSlotKind;
+    context: TContext;
+}
+
+export declare interface SlotOptions<TKind extends UiSlotKind = UiSlotKind> {
+    kind: TKind;
+    label?: string;
+    description?: string;
+    metadata?: JsonObject;
+}
+
+export declare interface SlotRef<TContext extends Struct = Struct, TKind extends UiSlotKind = UiSlotKind> {
+    id: string;
+    kind: TKind;
+    label?: string;
+    description?: string;
+    metadata?: JsonObject;
+    /** Phantom field used to constrain compatible contributions; never populated at runtime. */
+    context?: TContext;
+}
+
+export declare interface StatusActionDefinition {
+    readonly id: string;
+    readonly label: Localizable<string>;
+    readonly icon?: string;
+}
+
+export declare interface StatusBarItemContribution extends ContributionDefinition<"status-bar-item"> {
+    readonly view: ViewRef;
+    readonly slot: StatusBarSlotRef;
+    readonly order?: number;
+    readonly when?: WhenExpression;
+}
+
+export declare interface StatusBarSlotRef {
+    readonly id: string;
+}
+
+export declare interface StatusContribution extends ContributionDefinition<"status"> {
+    readonly title: Localizable<string>;
+    readonly actions?: readonly StatusActionDefinition[];
+    readonly query: (ctx: ExtensionContextBase, input: Record<string, never>) => MaybePromise<{
+        statuses: readonly WorkflowStatus[];
+    }>;
+    readonly save?: (ctx: ExtensionContextBase, input: {
+        statuses: readonly WorkflowStatus[];
+    }) => MaybePromise<{
+        statuses: readonly WorkflowStatus[];
+    }>;
+}
+
+export declare type StatusRef = ContributionRef<"status">;
+
+export declare type StepFinishPart = {
+    type: "step-finish";
+    reason?: string;
+    snapshot?: string;
+    cost?: number;
+    tokens?: unknown;
+};
+
+export declare type StepStartPart = {
+    type: "step-start";
+    snapshot?: string;
+};
+
+export declare type StorageScope = {
+    type: "project";
+} | {
+    type: "repo";
+    repoId: string;
+} | {
+    type: "resource";
+    resource: ResourceRef;
+} | {
+    type: string;
+    id: string;
+};
+
+export declare type Struct = object;
+
+export declare interface TemplateContribution extends ContributionDefinition<"template"> {
+    title: Localizable<string>;
+    type: string;
+    source: PackageAssetDescriptor;
+    description?: Localizable<string>;
+}
+
+export declare type TemplateParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<string, TRequired> & {
+    type: "template";
+    templateType: string;
+};
+
+export declare interface TemplateTypeContribution extends ContributionDefinition<"template-type"> {
+    label: Localizable<string>;
+    description?: Localizable<string>;
+    order?: number;
+    commands?: {
+        list: CommandRef;
+        read: CommandRef;
+        save: CommandRef;
+        delete: CommandRef;
+    };
+}
+
+export declare type TerminalEvent = {
+    kind: "data";
+    chunk: Uint8Array;
+} | {
+    kind: "title";
+    title: string;
+} | {
+    kind: "exit";
+    code: number | null;
+    signal: string | null;
+} | {
+    kind: "error";
+    message: string;
+};
+
+/**
+ * Renderer-side session over the `terminal.session` capability. Structurally
+ * compatible with the `TerminalSessionAdapter` contract of `@pstdio/ui/terminal`,
+ * so it plugs straight into the `Terminal` component's `bridge` prop.
+ */
+export declare interface TerminalSessionAdapter {
+    readonly id: string;
+    write(data: string | Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    kill(signal?: string): Promise<void>;
+    onData(handler: (chunk: Uint8Array) => void): () => void;
+    onExit(handler: (exit: TerminalSessionExit) => void): () => void;
+    onError(handler: (error: {
+        message: string;
+    }) => void): () => void;
+}
+
+export declare interface TerminalSessionBridge {
+    openSession(request: TerminalSessionRequest_2): Promise<TerminalSessionAdapter>;
+}
+
+export declare interface TerminalSessionExit {
+    code: number | null;
+    signal: string | null;
+}
+
+export declare interface TerminalSessionHandle {
+    /** Stable session id. */
+    readonly id: string;
+    /** Send stdin to the PTY. */
+    write(data: string | Uint8Array): void;
+    /** Adjust the PTY geometry. */
+    resize(cols: number, rows: number): void;
+    /** Terminate the child and clean up host resources. */
+    kill(signal?: string): Promise<void>;
+    /**
+     * Async iterable of output / exit / error events. A single iterator is
+     * supported per session — calling this twice throws. `exit` is always the
+     * last event delivered for a session.
+     */
+    events(): AsyncIterable<TerminalEvent>;
+}
+
+declare type TerminalSessionOperation = {
+    operation: "open";
+    request: TerminalSessionRequest;
+} | {
+    operation: "write";
+    sessionId: string;
+    data: string | Uint8Array;
+} | {
+    operation: "resize";
+    sessionId: string;
+    cols: number;
+    rows: number;
+} | {
+    operation: "kill";
+    sessionId: string;
+    signal?: string;
+} | {
+    operation: "subscribe";
+    sessionId: string;
+};
+
+export declare interface TerminalSessionRequest {
+    /** Command + args to run; defaults to the user's login shell when omitted. */
+    command?: string[];
+    /** Working directory; falls back to the extension's workspace root. */
+    cwd?: string;
+    /** Extra env vars merged over the inherited environment. */
+    env?: Record<string, string>;
+    /** Initial column count; the renderer can resize later. */
+    cols: number;
+    /** Initial row count; the renderer can resize later. */
+    rows: number;
+}
+
+declare interface TerminalSessionRequest_2 {
+    /** Command + args to run; defaults to the user's login shell when omitted. */
+    command?: string[];
+    /** Working directory; falls back to the extension's workspace root. */
+    cwd?: string;
+    /** Extra env vars merged over the inherited environment. */
+    env?: Record<string, string>;
+    /** Initial column count; the renderer can resize later. */
+    cols: number;
+    /** Initial row count; the renderer can resize later. */
+    rows: number;
+}
+
+declare type TerminalSessionResult = {
+    operation: "open";
+    sessionId: string;
+} | {
+    operation: "write" | "resize" | "kill" | "subscribe";
+    accepted: true;
+};
+
+export declare interface TextControl extends BaseControl {
+    type: "text";
+    defaultValue: string;
+    singleLine?: boolean;
+}
+
+export declare type TextParam<TRequired extends boolean | undefined = boolean | undefined> = ParamBase<string, TRequired> & {
+    type: "text";
+};
+
+export declare type TextPart = {
+    type: "text";
+    text: string;
+};
+
+export declare interface ThemeContribution extends ContributionDefinition<"theme"> {
+    title: Localizable<string>;
+    source: PackageAssetDescriptor;
+    format: "vscode-color-theme";
+    mode?: ThemeMode;
+    description?: Localizable<string>;
+}
+
+export declare type ThemeMode = "light" | "dark";
+
+export declare type ThemeRef = ContributionRef<"theme">;
+
+/** "activity": the host kills the session when no events arrive for a while; "provider": the provider self-terminates. */
+export declare type TimeoutStrategy = "activity" | "provider";
+
+export declare type TokenUsagePart = {
+    type: "token_usage";
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+};
+
+export declare type ToolPart = {
+    type: "tool";
+    tool: string;
+    callId?: string;
+    actionType?: ToolPartActionType;
+    status?: ToolPartStatus;
+    state?: {
+        status?: string;
+        input?: unknown;
+        output?: unknown;
+        errorText?: string;
+        metadata?: unknown;
+    };
+};
+
+export declare type ToolPartActionType = "read" | "write" | "execute" | "network" | "other";
+
+export declare type ToolPartStatus = "pending" | "running" | "completed" | "failed" | "denied";
+
+export declare interface TreeAction {
+    id: string;
+    label?: Localizable<string>;
+    icon?: string;
+    command?: CommandRef<Struct, unknown>;
+    params?: Struct;
+    input?: ParamObjectSchema;
+    submitLabel?: string;
+    when?: string;
+    disabled?: boolean;
+}
+
+export declare interface TreeNode {
+    id: string;
+    label: Localizable<string>;
+    icon?: string;
+    iconColor?: string;
+    iconTooltip?: string;
+    resource?: TreeRendererResourceRef;
+    target?: TreeNodeTarget;
+    /** Visual row variant for non-data rows such as placeholders. */
+    rowVariant?: TreeNodeRowVariant;
+    actions?: TreeAction[];
+    contextMenuActions?: TreeAction[];
+    collapsible?: boolean;
+    disabled?: boolean;
+    selected?: boolean;
+    children?: TreeNode[];
+    description?: string;
+    contextValue?: string;
+    hiddenByDefault?: boolean;
+    /** Opt in to the tree's hide/show customization menu (header/footer rows). Off by default. */
+    canHide?: boolean;
+    metadata?: JsonObject;
+}
+
+export declare type TreeNodeRowVariant = "empty-state";
+
+export declare type TreeNodeTarget = NavigationTarget;
+
+export declare interface TreeRendererActionParams extends TreeRendererQueryParams {
+    actionId: string;
+    node?: TreeNode;
+}
+
+export declare interface TreeRendererChildrenParams extends TreeRendererQueryParams {
+    node: TreeNode;
+}
+
+export declare type TreeRendererCommandResult = TreeViewSection[] | TreeNode[] | JsonValue;
+
+export declare interface TreeRendererContribution extends RendererContributionBase {
+    searchable?: boolean;
+    searchPlaceholder?: Localizable<string>;
+    header?: RendererCallback<TreeRendererQueryParams, TreeViewSection[]>;
+    body: RendererCallback<TreeRendererQueryParams, TreeViewSection[]>;
+    children?: RendererCallback<TreeRendererChildrenParams, TreeNode[]>;
+    footer?: RendererCallback<TreeRendererQueryParams, TreeViewSection[]>;
+    defaultExpandedSectionIds?: string[];
+    defaultExpandedNodeIds?: string[];
+}
+
+export declare interface TreeRendererQueryParams {
+    renderer: RendererContext;
+    state?: TreeRendererState;
+    filter?: string;
+}
+
+export declare type TreeRendererResourceRef = ResourceRef;
+
+export declare interface TreeRendererState {
+    expandedNodeIds: string[];
+    expandedSectionIds: string[];
+    selectedNodeId?: string;
+}
+
+export declare interface TreeSectionEmptyState {
+    title: Localizable<string>;
+    description?: Localizable<string>;
+    icon?: string;
+}
+
+export declare type TreeViewBody = NativeViewBody<"tree", TreeRendererContribution>;
+
+export declare interface TreeViewSection {
+    id: string;
+    label?: Localizable<string>;
+    actions?: TreeAction[];
+    collapsible?: boolean;
+    emptyState?: TreeSectionEmptyState;
+    nodes: TreeNode[];
+    hiddenByDefault?: boolean;
+    /** Opt in to the tree's hide/show customization menu (a category). Off by default. */
+    canHide?: boolean;
+}
+
+/** UI surface contributions: views, typed references, and placements. */
+export declare interface UiContributions {
+    views?: readonly ViewContribution[];
+    viewMenus?: readonly ViewMenuContribution[];
+    placements?: readonly PlacementContribution[];
+    navigationItems?: readonly NavigationItemContribution[];
+    navigationTrees?: readonly NavigationTreeContribution[];
+    statusBarItems?: readonly StatusBarItemContribution[];
+    statuses?: readonly StatusContribution[];
+    modes?: readonly ModeContribution[];
+    pages?: readonly PageContribution[];
+    resourceKinds?: readonly ResourceKindDefinition[];
+    activityItems?: readonly ActivityItemContribution[];
+    settingsSections?: readonly SettingsSectionContribution[];
+    settingsPanels?: readonly SettingsPanelContribution[];
+    commandPaletteResources?: readonly CommandPaletteResourceContribution[];
+    keybindings?: readonly KeybindingContribution[];
+}
+
+export declare type UiSlotKind = "menu" | "panel" | "settings" | "renderer" | "kanbanRenderer" | "dataTableRenderer";
+
+export declare const unwrapCommandOutcome: <TResult>(response: CommandResponse<TResult>, fallbackReason?: string) => TResult;
+
+export declare interface UpdateNotificationInput {
+    priority?: NotificationPriority;
+    snoozedUntil?: string | null;
+    metadata?: JsonObject;
+}
+
+/** Paired x/y numeric control. */
+export declare interface VectorControl extends BaseControl {
+    type: "vector";
+    defaultValue: VectorValue;
+    coordinateMode?: "cartesian" | "screen";
+    xLabel?: string;
+    yLabel?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+
+export declare type VectorValue = {
+    x: number;
+    y: number;
+};
+
+export declare type ViewBody = WebviewViewBody | TreeViewBody | FileViewBody | ControlsViewBody | KanbanViewBody | DataTableViewBody;
+
+export declare interface ViewContribution extends ContributionDefinition<"view"> {
+    readonly title: Localizable<string>;
+    readonly icon?: string;
+    readonly body: ViewBody;
+}
+
+declare type ViewDefinition = Omit<ViewContribution, "ref">;
+
+export declare interface ViewHierarchyParent {
+    type: "view";
+    viewId: string;
+}
+
+export declare interface ViewMenuContribution extends ContributionDefinition<"view-menu"> {
+    readonly owner: ViewRef;
+    readonly view: ViewRef;
+    readonly side: "left" | "right";
+    readonly group?: string;
+    readonly placement?: "first" | "default" | "last";
+    readonly hostTreeHeader?: "default" | "none";
+    readonly hostTreeFooter?: "default" | "none";
+}
+
+declare type ViewMenuDefinition = Omit<ViewMenuContribution, "ref">;
+
+export declare type ViewRef = ContributionRef<"view">;
+
+export declare const WEBVIEW_DECLARABLE_CAPABILITIES: readonly ["commands.execute", "navigation.open", "placement.close", "notification.show", "notification.action", "notification.resolve", "notification.dismiss", "preferences.get", "preferences.set", "extension.settings.all", "extension.settings.get", "extension.settings.set", "extension.settings.delete", "terminal.session", "files.upload", "files.list", "files.delete"];
+
+export declare const WEBVIEW_HOST_CAPABILITIES: readonly ["commands.execute", "navigation.open", "placement.close", "notification.show", "notification.action", "notification.resolve", "notification.dismiss", "preferences.get", "preferences.set", "extension.settings.all", "extension.settings.get", "extension.settings.set", "extension.settings.delete", "terminal.session", "files.upload", "files.list", "files.delete", "artifacts.read", "host.dispatchKeyboardEvent"];
+
+export declare const WEBVIEW_HOST_CAPABILITY_VERSION = 1;
+
+export declare const WEBVIEW_SCOPED_DECLARABLE_CAPABILITIES: readonly ["artifacts.read"];
+
+export declare interface WebviewArtifactFile {
+    path: string;
+    size: number;
+    mediaType: string;
+}
+
+export declare type WebviewArtifactsClient = {
+    list: (mount: ArtifactMountKey, prefix?: string) => Promise<WebviewArtifactFile[]>;
+    readText: (mount: ArtifactMountKey, path: string) => Promise<string>;
+    /** Short-lived URL for an allowlisted raster image, usable in `<img src>`. */
+    imageUrl: (mount: ArtifactMountKey, path: string) => Promise<string>;
+};
+
+export declare type WebviewArtifactsReadParams = {
+    op: "list";
+    mount: string;
+    prefix?: string;
+} | {
+    op: "readText";
+    mount: string;
+    path: string;
+} | {
+    op: "imageUrl";
+    mount: string;
+    path: string;
+};
+
+export declare type WebviewCapabilityDeclaration = WebviewDeclarableCapability | `${WebviewDeclarableCapability}@${typeof WEBVIEW_HOST_CAPABILITY_VERSION}` | `${WebviewScopedDeclarableCapability}:${string}`;
+
+export declare type WebviewClient<TCommands, TSettings = undefined> = {
+    artifacts: WebviewArtifactsClient;
+    commands: WebviewCommandsClient<TCommands>;
+    settings: WebviewSettingsClient<ClientSettingsMap<TSettings>>;
+};
+
+export declare interface WebviewClientOptions {
+    /** Overrides the extension id provided by the host bridge (e.g. in tests). */
+    extensionId?: string;
+}
+
+export declare type WebviewCommandsClient<TCommands> = {
+    [K in keyof TCommands & string]: CommandFn<TCommands[K]>;
+};
+
+export declare interface WebviewCommandsExecuteParams {
+    commandId: string;
+    params?: JsonObject;
+    resource?: ResourceRef;
+    repo?: RepoContext;
+    metadata?: JsonObject;
+}
+
+export declare interface WebviewContribution {
+    entry: PackageAssetDescriptor;
+    title?: Localizable<string>;
+    capabilities?: WebviewCapabilityDeclaration[];
+}
+
+export declare type WebviewDeclarableCapability = (typeof WEBVIEW_DECLARABLE_CAPABILITIES)[number];
+
+export declare interface WebviewExtensionSettingKeyParams {
+    key: string;
+}
+
+export declare interface WebviewExtensionSettingSetParams extends WebviewExtensionSettingKeyParams {
+    value: unknown;
+}
+
+export declare interface WebviewFilesClient {
+    pick(opts?: {
+        accept?: string;
+        multiple?: boolean;
+    }): Promise<File[]>;
+    upload(input: {
+        name: string;
+        data: Uint8Array | ArrayBuffer;
+        mimeType?: string;
+        scope?: {
+            type: string;
+            id?: string;
+        };
+    }): Promise<ExtensionBlobRef>;
+    list(input?: {
+        scope?: {
+            type: string;
+            id?: string;
+        };
+    }): Promise<ExtensionBlobRef[]>;
+    delete(id: string): Promise<void>;
+}
+
+export declare type WebviewFileScope = {
+    type: "project";
+} | {
+    type: "repo";
+    id: string;
+} | {
+    type: "resource";
+    id: string;
+} | {
+    type: string;
+    id?: string;
+};
+
+export declare interface WebviewFilesDeleteParams {
+    id: string;
+}
+
+export declare interface WebviewFilesListParams {
+    scope?: WebviewFileScope;
+}
+
+export declare interface WebviewFilesUploadParams {
+    name: string;
+    data: Uint8Array | ArrayBuffer;
+    mimeType?: string;
+    scope?: WebviewFileScope;
+}
+
+export declare type WebviewHostCapability = (typeof WEBVIEW_HOST_CAPABILITIES)[number];
+
+export declare interface WebviewHostCapabilityParams {
+    "commands.execute": WebviewCommandsExecuteParams;
+    "navigation.open": WebviewNavigationOpenParams;
+    "placement.close": Record<string, never>;
+    "notification.show": WebviewNotificationShowParams;
+    "notification.action": WebviewNotificationActionParams;
+    "notification.resolve": WebviewNotificationResolveParams;
+    "notification.dismiss": WebviewNotificationDismissParams;
+    "preferences.get": WebviewPreferencesGetParams;
+    "preferences.set": WebviewPreferencesSetParams;
+    "extension.settings.all": Record<string, never>;
+    "extension.settings.get": WebviewExtensionSettingKeyParams;
+    "extension.settings.set": WebviewExtensionSettingSetParams;
+    "extension.settings.delete": WebviewExtensionSettingKeyParams;
+    "terminal.session": TerminalSessionOperation;
+    "files.upload": WebviewFilesUploadParams;
+    "files.list": WebviewFilesListParams;
+    "files.delete": WebviewFilesDeleteParams;
+    "artifacts.read": WebviewArtifactsReadParams;
+    "host.dispatchKeyboardEvent": WebviewKeyboardEventParams;
+}
+
+export declare type WebviewHostCapabilityResult<Capability extends WebviewHostCapability, Params extends WebviewHostCapabilityParams[Capability] = WebviewHostCapabilityParams[Capability]> = Capability extends "artifacts.read" ? Params extends {
+    op: "list";
+} ? WebviewArtifactFile[] : Params extends {
+    op: "readText" | "imageUrl";
+} ? string : WebviewHostCapabilityResults[Capability] : Capability extends "terminal.session" ? Params extends {
+    operation: "open";
+} ? Extract<TerminalSessionResult, {
+    operation: "open";
+}> : Params extends {
+    operation: "write" | "resize" | "kill" | "subscribe";
+} ? Exclude<TerminalSessionResult, {
+    operation: "open";
+}> : TerminalSessionResult : WebviewHostCapabilityResults[Capability];
+
+export declare interface WebviewHostCapabilityResults {
+    "commands.execute": {
+        outcome: CommandOutcome;
+    };
+    "navigation.open": void;
+    "placement.close": void;
+    "notification.show": void;
+    "notification.action": Notification_2;
+    "notification.resolve": Notification_2 | {
+        resolved: number;
+        notifications: Notification_2[];
+    };
+    "notification.dismiss": Notification_2 | {
+        resolved: number;
+        notifications: Notification_2[];
+    };
+    "preferences.get": WebviewPreferencesSetParams["value"] | undefined;
+    "preferences.set": {
+        name: string;
+        value: WebviewPreferencesSetParams["value"];
+    };
+    "extension.settings.all": Record<string, unknown>;
+    "extension.settings.get": unknown;
+    "extension.settings.set": void;
+    "extension.settings.delete": void;
+    "terminal.session": TerminalSessionResult;
+    "files.upload": ExtensionBlobRef;
+    "files.list": {
+        files: ExtensionBlobRef[];
+    };
+    "files.delete": void;
+    "artifacts.read": WebviewArtifactFile[] | string;
+    "host.dispatchKeyboardEvent": void;
+}
+
+export declare interface WebviewKeyboardEventParams {
+    key?: string;
+    code?: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    repeat?: boolean;
+}
+
+export declare interface WebviewNavigationOpenParams {
+    target: NavigationTarget;
+}
+
+export declare type WebviewNotificationActionParams = Omit<CreateNotificationInput, "projectId">;
+
+export declare type WebviewNotificationDismissParams = Pick<WebviewNotificationResolveParams, "id" | "dedupeKey">;
+
+export declare interface WebviewNotificationResolveParams {
+    id?: string;
+    dedupeKey?: string;
+    status?: Extract<NotificationStatus, "done" | "dismissed" | "expired">;
+}
+
+export declare interface WebviewNotificationShowParams {
+    level: "info" | "success" | "warning" | "error";
+    title: string;
+    message?: string;
+}
+
+export declare interface WebviewPreferencesGetParams {
+    name: string;
+    scope?: {
+        scope: "default" | "user" | "project" | "repo" | "workspace" | "extension" | "session";
+        scopeId?: string;
+    };
+}
+
+export declare interface WebviewPreferencesSetParams extends WebviewPreferencesGetParams {
+    value: boolean | number | string | string[] | number[] | boolean[] | Record<string, unknown>;
+}
+
+export declare type WebviewScopedDeclarableCapability = (typeof WEBVIEW_SCOPED_DECLARABLE_CAPABILITIES)[number];
+
+export declare type WebviewSettingsClient<TSettings> = {
+    all: () => Promise<Partial<TSettings>>;
+    get: <K extends keyof TSettings & string>(key: K) => Promise<TSettings[K] | undefined>;
+    set: <K extends keyof TSettings & string>(key: K, value: TSettings[K]) => Promise<void>;
+};
+
+export declare type WebviewViewBody = {
+    readonly kind: "webview";
+} & WebviewContribution;
+
+export declare interface WhenExpression {
+    mode?: ModeRef | readonly ModeRef[];
+    source?: CommandSource[];
+    view?: ViewRef | readonly ViewRef[];
+    resourceType?: readonly ResourceKindRef[];
+    metadata?: JsonObject;
+}
+
+export declare interface WorkbenchAttachmentInvocationContext {
+    target: WorkbenchAttachmentTarget;
+    mode?: string;
+    projectId?: string;
+    resource?: ResourceRef;
+}
+
+declare type WorkbenchAttachmentTarget = WorkbenchMenuTarget | WorkbenchTreeTarget | WorkbenchViewTarget | WorkbenchSettingsTarget;
+
+declare type WorkbenchMenuTarget = (typeof workbenchMenuTargets)[number];
+
+declare const workbenchMenuTargets: readonly ["workbench.nav.actions", "workbench.nav.overflow"];
+
+export declare const workbenchModeDefinitions: {
+    readonly project: {
+        readonly ref: {
+            extensionId: string;
+            kind: "mode";
+            id: string;
+        };
+        readonly regions: readonly ["sidenav", "main", "secondary", "side"];
+    };
+    readonly sessions: {
+        readonly ref: {
+            extensionId: string;
+            kind: "mode";
+            id: string;
+        };
+        readonly regions: readonly ["sidenav", "main", "secondary", "side"];
+    };
+    readonly settings: {
+        readonly ref: {
+            extensionId: string;
+            kind: "mode";
+            id: string;
+        };
+        readonly regions: readonly ["sidenav", "main", "secondary", "side"];
+    };
+};
+
+export declare const workbenchModes: {
+    project: {
+        extensionId: string;
+        kind: "mode";
+        id: string;
+    };
+    sessions: {
+        extensionId: string;
+        kind: "mode";
+        id: string;
+    };
+    settings: {
+        extensionId: string;
+        kind: "mode";
+        id: string;
+    };
+};
+
+export declare const workbenchPageDefinitions: {
+    readonly start: {
+        readonly ref: {
+            extensionId: string;
+            kind: "page";
+            id: string;
+        };
+        readonly mode: {
+            extensionId: string;
+            kind: "mode";
+            id: string;
+        };
+        readonly path: "";
+        readonly primary: {
+            readonly cardinality: "one";
+            readonly resourceKinds: readonly [];
+        };
+    };
+    readonly sessions: {
+        readonly ref: {
+            extensionId: string;
+            kind: "page";
+            id: string;
+        };
+        readonly mode: {
+            extensionId: string;
+            kind: "mode";
+            id: string;
+        };
+        readonly path: "sessions";
+        readonly primary: {
+            readonly cardinality: "one";
+            readonly resourceKinds: readonly [];
+        };
+    };
+    readonly session: {
+        readonly ref: {
+            extensionId: string;
+            kind: "page";
+            id: string;
+        };
+        readonly mode: {
+            extensionId: string;
+            kind: "mode";
+            id: string;
+        };
+        readonly path: "session";
+        readonly primary: {
+            readonly cardinality: "one";
+            readonly resourceKinds: readonly ["session", "session-draft"];
+        };
+    };
+    readonly workspaces: {
+        readonly ref: {
+            extensionId: string;
+            kind: "page";
+            id: string;
+        };
+        readonly mode: {
+            extensionId: string;
+            kind: "mode";
+            id: string;
+        };
+        readonly path: "workspaces";
+        readonly primary: {
+            readonly cardinality: "one";
+            readonly resourceKinds: readonly [];
+        };
+    };
+    readonly workspace: {
+        readonly ref: {
+            extensionId: string;
+            kind: "page";
+            id: string;
+        };
+        readonly mode: {
+            extensionId: string;
+            kind: "mode";
+            id: string;
+        };
+        readonly path: "workspace";
+        readonly primary: {
+            readonly cardinality: "many";
+            readonly resourceKinds: readonly ["workspace"];
+        };
+    };
+};
+
+export declare const workbenchPages: {
+    start: {
+        extensionId: string;
+        kind: "page";
+        id: string;
+    };
+    sessions: {
+        extensionId: string;
+        kind: "page";
+        id: string;
+    };
+    session: {
+        extensionId: string;
+        kind: "page";
+        id: string;
+    };
+    workspaces: {
+        extensionId: string;
+        kind: "page";
+        id: string;
+    };
+    workspace: {
+        extensionId: string;
+        kind: "page";
+        id: string;
+    };
+};
+
+export declare const workbenchPanelDefinitions: {
+    readonly projectSession: {
+        readonly ref: {
+            extensionId: string;
+            kind: "placement";
+            id: string;
+        };
+        readonly mode: {
+            extensionId: string;
+            kind: "mode";
+            id: string;
+        };
+        readonly cardinality: "many";
+        readonly resourceKinds: readonly ["session", "session-draft"];
+    };
+};
+
+export declare const workbenchPanels: {
+    projectSession: {
+        extensionId: string;
+        kind: "placement";
+        id: string;
+    };
+};
+
+export declare const workbenchResourceKindDefinitions: {
+    project: ResourceKindDefinition;
+    session: ResourceKindDefinition;
+    workspace: ResourceKindDefinition;
+};
+
+export declare const workbenchResourceKinds: {
+    project: ContributionRef<"resource-kind">;
+    session: ContributionRef<"resource-kind">;
+    workspace: ContributionRef<"resource-kind">;
+};
+
+declare type WorkbenchSettingsTarget = (typeof workbenchSettingsTargets)[number];
+
+declare const workbenchSettingsTargets: readonly ["workbench.settings"];
+
+export declare const workbenchSlots: {
+    projectSettings: {
+        extensionId: string;
+        kind: "settings-panel";
+        id: string;
+    };
+    statusBarLeading: {
+        extensionId: string;
+        kind: "status-bar-item";
+        id: string;
+    };
+    statusBarTrailing: {
+        extensionId: string;
+        kind: "status-bar-item";
+        id: string;
+    };
+};
+
+declare type WorkbenchTreeTarget = (typeof workbenchTreeTargets)[number];
+
+declare const workbenchTreeTargets: readonly ["workbench.left.tree", "workbench.main.left.tree", "workbench.main.right.tree"];
+
+declare type WorkbenchViewTarget = (typeof workbenchViewTargets)[number];
+
+declare const workbenchViewTargets: readonly ["workbench.main", "workbench.main.left", "workbench.main.right", "workbench.secondary"];
+
+export declare interface WorkflowStatus {
+    readonly id: string;
+    readonly label: string;
+    readonly color: string;
+    readonly icon?: string | null;
+    readonly sortOrder: number;
+    readonly isDefault?: boolean;
+    readonly actions?: readonly string[];
+}
+
+export declare interface WorkspaceCapabilities {
+    files: "none" | "read" | "write";
+    diff: boolean;
+    merge: boolean;
+    rebase: boolean;
+    archive: boolean;
+    delete: boolean;
+}
+
+export declare const workspaceEvents: {
+    created: EventRef<    {
+    workspace: ExtensionWorkspace;
+    }>;
+    /** Awaited: harness extensions sync their agent dir into the working tree. Gates workspace readiness. */
+    provision: EventRef<WorkspaceProvisionPayload>;
+    /** Fire-and-forget after the workspace is ready: background setup (deps install, builds). */
+    ready: EventRef<WorkspaceProvisionPayload>;
+    archived: EventRef<    {
+    workspace: ExtensionWorkspace;
+    }>;
+    deleted: EventRef<    {
+    workspace: ExtensionWorkspace;
+    }>;
+};
+
+export declare type WorkspaceExecutionTarget = {
+    kind: "local";
+    rootPath: string;
+    displayPath?: string;
+} | {
+    kind: "remote";
+    providerId: string;
+    providerRef: WorkspaceProviderRef;
+    displayPath?: string;
+};
+
+export declare interface WorkspaceFilesMount extends ArtifactMount {
+    /**
+     * Write each file atomically (temp + rename) and prune files managed by an earlier sync that are no
+     * longer present. Other files under `dir` are preserved. Idempotent and safe to re-run on every
+     * catalog change; a live agent's dir-watcher only ever sees complete files.
+     */
+    syncDir(dir: string, files: WorkspaceSyncFile[]): Promise<void>;
+}
+
+export declare interface WorkspaceProviderCreateInput {
+    operationId: string;
+    projectId: string;
+    workspaceId: string;
+    params: JsonObject;
+    /** Host-owned cancellation for the workspace creation request. */
+    signal?: AbortSignal;
+}
+
+export declare interface WorkspaceProviderMutationInput extends WorkspaceProviderResolveInput {
+    operationId: string;
+}
+
+export declare interface WorkspaceProviderRef {
+    version: number;
+    data: JsonObject;
+}
+
+export declare interface WorkspaceProviderResolveInput {
+    projectId: string;
+    workspaceId: string;
+    providerRef: WorkspaceProviderRef;
+}
+
+export declare interface WorkspaceProviderResult {
+    providerRef?: WorkspaceProviderRef;
+    /** Git branch exposed to host merge and diff features. Provider refs stay opaque. */
+    branch?: string;
+    state: WorkspaceProviderState;
+    executionKind: "local" | "remote";
+    executionTarget?: WorkspaceExecutionTarget;
+    displayPath?: string;
+    capabilities: WorkspaceCapabilities;
+    error?: {
+        code: string;
+        message: string;
+        retryable: boolean;
+    };
+}
+
+export declare type WorkspaceProviderState = "provisioning" | "ready" | "failed" | "cancelled" | "archiving" | "archived" | "deleting" | "provider_missing";
+
+export declare interface WorkspaceProvisionPayload {
+    projectId: string;
+    workspaceId: string;
+    workspace: ExtensionWorkspace;
+    /** Absolute working directory to materialize files into — a worktree path or the repo root. */
+    workspaceDir: string;
+    repoPath: string;
+    branch?: string;
+    type: WorkspaceType;
+}
+
+export declare const workspaceSlots: {
+    headerPrimary: SlotRef<object, "menu">;
+    headerOverflow: SlotRef<object, "menu">;
+    sidenav: SlotRef<object, "panel">;
+};
+
+export declare interface WorkspaceSyncFile {
+    /** Path relative to the `dir` passed to {@link WorkspaceFilesMount.syncDir}. */
+    path: string;
+    content: string;
+}
+
+/** How a workspace's working tree is backed. `root` = the repo checkout itself; `cloud` is reserved. */
+export declare type WorkspaceType = "worktree" | "root" | "cloud";
+
+export declare interface WorkspaceTypeProvider extends ContributionDefinition<"workspace-type"> {
+    label: Localizable<string>;
+    params?: ParamObjectSchema;
+    create(ctx: ExtensionContextBase, input: WorkspaceProviderCreateInput): MaybePromise<WorkspaceProviderResult>;
+    resolve(ctx: ExtensionContextBase, input: WorkspaceProviderResolveInput): MaybePromise<WorkspaceProviderResult>;
+    cancel?(ctx: ExtensionContextBase, input: WorkspaceProviderMutationInput): MaybePromise<WorkspaceProviderResult>;
+    archive?(ctx: ExtensionContextBase, input: WorkspaceProviderMutationInput): MaybePromise<WorkspaceProviderResult>;
+    delete?(ctx: ExtensionContextBase, input: WorkspaceProviderMutationInput): MaybePromise<void>;
+}
+
+export declare const worktreeEvents: {
+    removed: EventRef<WorktreeRemovedPayload>;
+};
+
+export declare interface WorktreeRemovedPayload {
+    projectId: string;
+    repoPath?: string;
+    worktreePath: string;
+    workspace?: ExtensionWorkspace;
+    workspaceId?: string;
+    anchors?: ResourceAnchor[];
+}
+
+export { }