@kmlckj/aios-agent-server-sdk 0.0.0-stage → 0.0.1

package/dist/shared/security-center-api.d.ts

@@ -0,0 +1,74 @@
+export type DesktopPlatform = 'macos' | 'windows' | 'linux' | 'other';
+export type LinuxSystemPermissionKind = 'linux-desktop' | 'linux-accessibility';
+export type SystemPermissionKind = 'full-disk-access' | 'accessibility' | 'automation' | LinuxSystemPermissionKind;
+export type SystemPermissionStatus = 'authorized' | 'not-authorized' | 'not-determined';
+export interface FileSecurityPolicy {
+    autoAllowPaths: string[];
+    requireApprovalPaths: string[];
+}
+export interface CommandSecurityPolicy {
+    allowCommands: string[];
+    requireApprovalCommands: string[];
+    denyCommands: string[];
+}
+export interface NetworkSecurityPolicy {
+    blockAll: boolean;
+    allowDomains: string[];
+    denyDomains: string[];
+}
+export interface DesktopSecurityPolicy {
+    file: FileSecurityPolicy;
+    command: CommandSecurityPolicy;
+    network: NetworkSecurityPolicy;
+}
+export type SecurityRuntimeToolId = 'python' | 'node' | 'git-bash';
+export type SecurityRuntimeToolEnablement = Record<SecurityRuntimeToolId, boolean>;
+export declare function createDefaultRuntimeToolEnablement(): SecurityRuntimeToolEnablement;
+export interface DesktopRuntimeSecuritySettings {
+    policy: DesktopSecurityPolicy;
+    deletionProtection: boolean;
+    runtimeToolsEnabled: SecurityRuntimeToolEnablement;
+}
+export declare const DEFAULT_SENSITIVE_FILE_PATHS_BY_PLATFORM: {
+    readonly macos: readonly ["~/.ssh/", "~/.aws/", "~/.gnupg/", "~/.gpg/", "~/.kube/config", "~/.docker/config.json", "~/.docker/daemon.json", "~/.netrc", "~/.npmrc", "~/.pypirc", "~/.gem/credentials", "~/.config/gh/hosts.yml", "~/.git-credentials", "~/.config/gcloud/", "~/.azure/", "~/.terraform.d/credentials.tfrc.json", "~/library/keychains/"];
+    readonly windows: readonly ["%USERPROFILE%\\.ssh\\", "%USERPROFILE%\\.aws\\", "%USERPROFILE%\\.kube\\config", "%USERPROFILE%\\.docker\\config.json", "%USERPROFILE%\\.docker\\daemon.json", "%USERPROFILE%\\.netrc", "%USERPROFILE%\\.npmrc", "%USERPROFILE%\\.pypirc", "%USERPROFILE%\\.gem\\credentials", "%USERPROFILE%\\.config\\gh\\hosts.yml", "%USERPROFILE%\\.git-credentials", "%USERPROFILE%\\.config\\gcloud\\", "%USERPROFILE%\\.azure\\", "%USERPROFILE%\\.terraform.d\\credentials.tfrc.json"];
+    readonly linux: readonly ["~/.ssh/", "~/.aws/", "~/.gnupg/", "~/.gpg/", "~/.kube/config", "~/.docker/config.json", "~/.docker/daemon.json", "~/.netrc", "~/.npmrc", "~/.pypirc", "~/.gem/credentials", "~/.config/gh/hosts.yml", "~/.git-credentials", "~/.config/gcloud/", "~/.azure/", "~/.terraform.d/credentials.tfrc.json", "/etc/", "/root/", "/boot/", "/dev/", "~/.local/share/keyrings/", "~/.password-store/"];
+    readonly other: readonly ["~/.ssh/", "~/.aws/", "~/.gnupg/", "~/.gpg/", "~/.kube/config", "~/.docker/config.json", "~/.docker/daemon.json", "~/.netrc", "~/.npmrc", "~/.pypirc", "~/.gem/credentials", "~/.config/gh/hosts.yml", "~/.git-credentials", "~/.config/gcloud/", "~/.azure/", "~/.terraform.d/credentials.tfrc.json"];
+};
+export declare function desktopPlatformFromNodePlatform(platform?: string): DesktopPlatform;
+export declare function currentDesktopPlatform(): DesktopPlatform;
+export declare function getDefaultSensitiveFilePaths(platform: DesktopPlatform): ("/etc/" | "/root/" | "/boot/" | "/dev/" | "~/.ssh/" | "~/.aws/" | "~/.gnupg/" | "~/.gpg/" | "~/.kube/config" | "~/.docker/config.json" | "~/.docker/daemon.json" | "~/.netrc" | "~/.npmrc" | "~/.pypirc" | "~/.gem/credentials" | "~/.config/gh/hosts.yml" | "~/.git-credentials" | "~/.config/gcloud/" | "~/.azure/" | "~/.terraform.d/credentials.tfrc.json" | "~/library/keychains/" | "%USERPROFILE%\\.ssh\\" | "%USERPROFILE%\\.aws\\" | "%USERPROFILE%\\.kube\\config" | "%USERPROFILE%\\.docker\\config.json" | "%USERPROFILE%\\.docker\\daemon.json" | "%USERPROFILE%\\.netrc" | "%USERPROFILE%\\.npmrc" | "%USERPROFILE%\\.pypirc" | "%USERPROFILE%\\.gem\\credentials" | "%USERPROFILE%\\.config\\gh\\hosts.yml" | "%USERPROFILE%\\.git-credentials" | "%USERPROFILE%\\.config\\gcloud\\" | "%USERPROFILE%\\.azure\\" | "%USERPROFILE%\\.terraform.d\\credentials.tfrc.json" | "~/.local/share/keyrings/" | "~/.password-store/")[];
+export declare function mergeDefaultSensitiveFilePaths(values: readonly string[], platform: DesktopPlatform): string[];
+export declare const DEFAULT_DENIED_COMMANDS: readonly ["rm -rf /", "rm -rf /*", "mkfs", "format c:", "diskpart clean", "clear-disk", "initialize-disk", "remove-partition", "remove-volume", "format-volume", "wmic partition delete", "wmic logicaldisk delete", "bcdedit /delete", "vssadmin delete shadows", "wbadmin delete", "shutdown", "reboot"];
+export declare function mergeDefaultDeniedCommands(values: string[], platform: DesktopPlatform): string[];
+export declare function createDefaultSecurityPolicy(platform?: DesktopPlatform): DesktopSecurityPolicy;
+export interface SecurityRuntimeTool {
+    id: SecurityRuntimeToolId;
+    name: string;
+    description: string;
+    available: boolean;
+    enabled: boolean;
+    version?: string;
+    systemVersion?: string;
+}
+export interface SecuritySystemPermission {
+    kind: SystemPermissionKind;
+    name: string;
+    description: string;
+    status: SystemPermissionStatus;
+    required: false;
+}
+export interface SecurityCenterSnapshot {
+    platform: DesktopPlatform;
+    sandboxEnabled: boolean;
+    commandApprovalEnabled: boolean;
+    networkAccessEnabled: boolean;
+    securityGatewayEnabled: boolean;
+    transportEncrypted: boolean;
+    runtimeTools: SecurityRuntimeTool[];
+    systemPermissions: SecuritySystemPermission[];
+}
+export interface SecurityCenterApi {
+    getSnapshot: () => Promise<SecurityCenterSnapshot>;
+    requestSystemPermission: (kind: SystemPermissionKind) => Promise<SecurityCenterSnapshot>;
+}

package/dist/shared/sensitive-protection-api.d.ts

@@ -0,0 +1,71 @@
+export type SensitiveRuleSource = 'system' | 'user';
+export type SensitiveDecision = 'original' | 'protect' | 'deny';
+export interface SensitiveRule {
+    id: string;
+    name: string;
+    source: SensitiveRuleSource;
+    enabled: boolean;
+    config: string;
+    keywords: boolean;
+    entropy: boolean;
+}
+export interface SensitiveEntry {
+    id: string;
+    name: string;
+    source: 'user';
+    enabled: boolean;
+    plaintext: string;
+    ciphertext: string;
+}
+/** A renderer projection, never an authorization decision or a substitute for scanning. */
+export interface SensitiveReference {
+    id: string;
+    ciphertext: string;
+    ruleNames: string[];
+}
+export interface SensitiveProtectionSnapshot {
+    enabled: boolean;
+    rules: SensitiveRule[];
+    entries: SensitiveEntry[];
+}
+export type SensitiveProtectionMutation = {
+    kind: 'enabled';
+    enabled: boolean;
+} | {
+    kind: 'rule';
+    id?: string;
+    name: string;
+    config: string;
+} | {
+    kind: 'rule-enabled';
+    id: string;
+    enabled: boolean;
+} | {
+    kind: 'rule-delete';
+    id: string;
+} | {
+    kind: 'entry';
+    name: string;
+    plaintext: string;
+} | {
+    kind: 'entry-enabled';
+    id: string;
+    enabled: boolean;
+} | {
+    kind: 'entry-delete';
+    id: string;
+};
+export interface SensitiveProtectionApi {
+    snapshot(): Promise<SensitiveProtectionSnapshot>;
+    update(request: SensitiveProtectionMutation): Promise<SensitiveProtectionSnapshot>;
+    reveal(taskId: string, id: string): Promise<string>;
+    references(taskId: string): Promise<SensitiveReference[]>;
+}
+export interface SensitiveMatch extends SensitiveReference {
+    plaintext: string;
+}
+export interface SensitiveInspection {
+    enabled: boolean;
+    matches: SensitiveMatch[];
+}
+export declare function sensitiveProtectionActive(permissionMode: string, enabled: boolean): boolean;

package/dist/shared/session-policy.d.ts

@@ -0,0 +1,26 @@
+import { type TaskPathPolicy } from './task-path-policy.js';
+export interface SessionMemoryPolicy {
+    scope: string;
+    read: boolean;
+    write: boolean;
+}
+export interface RunMemoryPolicy {
+    read?: boolean;
+    write?: boolean;
+}
+/** A turn may narrow the session grant, never widen it or change its namespace. */
+export declare function narrowMemoryPolicy(base: SessionMemoryPolicy | undefined, value?: unknown): SessionMemoryPolicy | undefined;
+export interface SessionScopePolicy {
+    scope: string;
+    memory: SessionMemoryPolicy;
+    paths?: TaskPathPolicy;
+}
+export interface ApplicationRule {
+    id: string;
+    version: string;
+    scope: 'application' | 'project' | 'session';
+    text: string;
+}
+export declare function parseSessionPolicy(value: unknown, sessionId: string): SessionScopePolicy;
+export declare function parseApplicationRules(value: unknown): ApplicationRule[];
+export declare function applicationInstructions(instructions: string, rules?: ApplicationRule[]): string;

package/dist/shared/shortcut-api.d.ts

@@ -0,0 +1,7 @@
+export declare const SHORTCUT_COMMANDS: readonly ["openSettings", "toggleVoice", "searchConversation", "sendMessage", "insertNewline", "newTask", "stopGeneration", "previousTask", "nextTask", "toggleSidebar", "toggleResourcePanel", "toggleFullscreen", "toggleMainWindow", "increaseFont", "decreaseFont", "resetFont", "openReferencePicker", "openSlashCommands"];
+export type ShortcutCommand = (typeof SHORTCUT_COMMANDS)[number];
+export type ShortcutBindings = Partial<Record<ShortcutCommand, string | null>>;
+export declare const MAC_DEFAULT_SHORTCUT_BINDINGS: Record<ShortcutCommand, string>;
+export declare const WINDOWS_DEFAULT_SHORTCUT_BINDINGS: Record<ShortcutCommand, string>;
+export declare function defaultShortcutBindings(isMac: boolean): Record<ShortcutCommand, string>;
+export declare const FIXED_SHORTCUT_COMMANDS: Set<"openSettings" | "toggleVoice" | "searchConversation" | "sendMessage" | "insertNewline" | "newTask" | "stopGeneration" | "previousTask" | "nextTask" | "toggleSidebar" | "toggleResourcePanel" | "toggleFullscreen" | "toggleMainWindow" | "increaseFont" | "decreaseFont" | "resetFont" | "openReferencePicker" | "openSlashCommands">;

package/dist/shared/skill-activation-api.d.ts

@@ -0,0 +1,8 @@
+export interface SetSkillEnabledRequest {
+    skillId: string;
+    enabled: boolean;
+}
+export interface SkillActivationApi {
+    listDisabledSkillIds: () => Promise<string[]>;
+    setEnabled: (request: SetSkillEnabledRequest) => Promise<void>;
+}

package/dist/shared/skill-asset-api.d.ts

@@ -0,0 +1,12 @@
+export interface SkillAssetReadRequest {
+    source: string;
+}
+export interface SkillAssetContent {
+    name: string;
+    mediaType: string;
+    sizeBytes: number;
+    data: ArrayBuffer;
+}
+export interface SkillAssetApi {
+    read: (request: SkillAssetReadRequest) => Promise<SkillAssetContent>;
+}

package/dist/shared/skill-market-api.d.ts

@@ -0,0 +1,119 @@
+export type SkillMarketPriceType = 'FREE' | 'PAID';
+export type SkillMarketScope = 'PLATFORM' | 'ENTERPRISE' | 'MINE';
+export declare function skillMarketItemKey(skill: {
+    skillId: string;
+    tenantId?: string | null;
+}): string;
+export interface SkillMarketItem {
+    executionScope?: string;
+    skillId: string;
+    /** Scope of the user's binding, independent of the tab/source label. */
+    tenantId?: string | null;
+    ownerType?: string | null;
+    name: string;
+    summary: string;
+    iconUrl: string | null;
+    priceType: SkillMarketPriceType;
+    priceLabel: string;
+    developerName: string;
+    isOpenSource: boolean;
+    isOfficial: boolean;
+    userCount: number;
+    userCountLabel: string;
+    categoryCode: string | null;
+    categoryName: string | null;
+    installed: boolean;
+    canInstall: boolean;
+    canUse: boolean;
+    publishStatus?: string | null;
+    publishedVersion?: string | null;
+    location?: 'CLOUD' | 'LOCAL';
+}
+export interface SkillMarketCategory {
+    categoryId: string | null;
+    categoryCode: string;
+    categoryName: string;
+    sortNo: number;
+}
+export interface SkillMarketSection {
+    sectionId: string;
+    sectionCode: string;
+    sectionName: string;
+    sortNo: number;
+    items: SkillMarketItem[];
+}
+export interface SkillMarketHome {
+    sections: SkillMarketSection[];
+}
+export interface SkillMarketSearchQuery {
+    scope?: SkillMarketScope;
+    enabledOnly?: boolean;
+    keyword?: string;
+    categoryCode?: string;
+    pageNum?: number;
+    pageSize?: number;
+}
+export interface SkillMarketSearchResult {
+    items: SkillMarketItem[];
+    total: number;
+    /** MINE merges two independently paginated collections; their union size is not a page cursor. */
+    hasMore?: boolean;
+}
+export interface SkillMarketVersion {
+    versionId: string;
+    versionNo: string;
+    packageRef: string | null;
+    deployStatus: string | null;
+    configJson: string | null;
+    changelog: string | null;
+    updatedAt: string | null;
+}
+export interface PrepareSkillForLocalTaskRequest {
+    skillId: string;
+    source: SkillMarketScope;
+    tenantId?: string | null;
+}
+export interface InstallSkillRequest {
+    skillId: string;
+    source: 'STORE' | 'ENTERPRISE';
+    tenantId?: string | null;
+}
+export interface SkillMarketRating {
+    averageScore: number;
+    ratingCount: number;
+    starCountMap: Record<string, number>;
+}
+export interface SkillMarketCase {
+    caseId: string;
+    title: string;
+    coverUrl: string | null;
+    description: string | null;
+}
+export interface SkillMarketUserState {
+    installed: boolean;
+    enabled: boolean;
+    purchased: boolean;
+    subscriptionExpired: boolean;
+    canInstall: boolean;
+    canUse: boolean;
+    canEnable: boolean;
+    hasUsed: boolean;
+    actionScope: string;
+    actionDisabledReason: string | null;
+}
+export interface SkillMarketDetail extends SkillMarketItem {
+    description: string;
+    currentVersion: SkillMarketVersion | null;
+    rating: SkillMarketRating;
+    cases: SkillMarketCase[];
+    userSkillState: SkillMarketUserState;
+}
+export interface SkillMarketApi {
+    getHome: () => Promise<SkillMarketHome>;
+    listCategories: () => Promise<SkillMarketCategory[]>;
+    search: (query?: SkillMarketSearchQuery) => Promise<SkillMarketSearchResult>;
+    getDetail: (skillId: string, tenantId?: string | null) => Promise<SkillMarketDetail>;
+    install: (request: InstallSkillRequest) => Promise<void>;
+    remove: (skillId: string, tenantId?: string | null) => Promise<void>;
+    prepareForLocalTask: (request: PrepareSkillForLocalTaskRequest) => Promise<import('./local-task-api.js').LocalTaskSkillReference>;
+}

package/dist/shared/skill-upload.d.ts

@@ -0,0 +1,16 @@
+export declare const PERSONAL_SKILL_UPLOAD_PATH: "/api/v1/skills/upload";
+export declare const MAX_SKILL_UPLOAD_BYTES: number;
+export interface PersonalSkillUploadRequest {
+    fileName: string;
+    data: ArrayBuffer;
+}
+export interface PersonalSkillUploadResult {
+    skillId: string;
+    versionId: string;
+    name: string;
+    scope: 'PERSONAL';
+    tenantId: null;
+    publishStatus: 'UNPUBLISHED';
+}
+export declare function validateSkillUploadFile(name: string, size: number): void;
+export declare function parsePersonalSkillUploadResult(value: unknown): PersonalSkillUploadResult;

package/dist/shared/speech-recognition-api.d.ts

@@ -0,0 +1,12 @@
+export interface SpeechRecognitionRequest {
+    audio: ArrayBuffer;
+    mediaType: 'audio/webm' | 'audio/mp4' | 'audio/wav';
+    durationMs: number;
+}
+export interface SpeechRecognitionResult {
+    text: string;
+    durationMs: number;
+}
+export interface SpeechRecognitionApi {
+    transcribe(request: SpeechRecognitionRequest): Promise<SpeechRecognitionResult>;
+}

package/dist/shared/storage-integrity.d.ts

@@ -0,0 +1,15 @@
+export type StorageProblem = 'missing' | 'temporarily_unavailable' | 'corrupt' | 'unsupported_version';
+export interface StorageIntegrityIssue {
+    canReset?: boolean;
+    id: string;
+    fileName: string;
+    status: StorageProblem;
+    message: string;
+    detectedAt: string;
+    recoveryAvailable: boolean;
+}
+export interface StorageIntegrityApi {
+    listIssues(): Promise<StorageIntegrityIssue[]>;
+    recover(issueId: string): Promise<void>;
+    reset(issueId: string): Promise<void>;
+}

package/dist/shared/target-bridge-protocol.d.ts

@@ -0,0 +1,67 @@
+import type { ExecutionTargetIdentity, ExecutionTargetPlatform } from './execution-target.js';
+/** Independent of the desktop, CLI product version, and private daemon protocol. */
+export declare const TARGET_BRIDGE_PROTOCOL = 1;
+export interface TargetBridgeInfo {
+    identity: ExecutionTargetIdentity;
+    platform: ExecutionTargetPlatform;
+    arch: string;
+    cliVersion: string;
+    daemonInstanceId: string;
+    protocol: {
+        min: number;
+        max: number;
+    };
+    capabilities: string[];
+}
+export interface BridgeRequestSession {
+    generation: string;
+    target: ExecutionTargetIdentity;
+    auth?: {
+        bindingId: string;
+        clientAuthGeneration: number;
+    };
+}
+export interface TargetBridgeRequest {
+    type: 'request';
+    requestId: string;
+    method: string;
+    params: Record<string, unknown>;
+    session?: BridgeRequestSession;
+}
+export type TargetBridgeResponse = {
+    type: 'response';
+    requestId: string;
+    generation?: string;
+    auth?: {
+        bindingId: string;
+        clientAuthGeneration: number;
+    };
+} & ({
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+});
+export interface TargetBridgeHello {
+    generation: string;
+    protocol: number;
+    target: TargetBridgeInfo;
+    authentication: {
+        state: 'unbound';
+    };
+}
+export interface TargetBridgeEvent {
+    type: 'event';
+    generation: string;
+    subscriptionId: string;
+    topic: string;
+    auth: {
+        bindingId: string;
+        clientAuthGeneration: number;
+    };
+    data: unknown;
+}

package/dist/shared/target-environments.d.ts

@@ -0,0 +1,15 @@
+import type { LocalEnvironmentCatalog, LocalEnvironmentFile, SaveLocalEnvironmentRequest } from './local-environment-api.js';
+export interface TargetEnvironmentMethods {
+    list(): Promise<LocalEnvironmentCatalog>;
+    save(request: SaveLocalEnvironmentRequest): Promise<LocalEnvironmentFile>;
+    remove(request: {
+        localWorkspaceId: string;
+        fileName: string;
+        expectedRevision: string;
+    }): Promise<void>;
+    select(request: {
+        localWorkspaceId: string;
+        environmentId?: string;
+    }): Promise<void>;
+}
+export declare const TARGET_ENVIRONMENT_NAMES: readonly (keyof TargetEnvironmentMethods)[];

package/dist/shared/target-resources.d.ts

@@ -0,0 +1,105 @@
+import type { TaskRef, WorkspaceRef } from './execution-target.js';
+import type { AvailableChatModel } from './cloud-assistant-api.js';
+import type { LocalCustomModel, SaveLocalCustomModelRequest } from './local-custom-model-api.js';
+import type { LocalPluginApi } from './local-plugin-api.js';
+import type { ProfessionMarketApi } from './profession-market-api.js';
+import type { TaskInitializationApi } from './task-initialization-api.js';
+import type { SkillMarketItem } from './skill-market-api.js';
+import type { LocalMcpServer, SaveLocalMcpServerRequest, SetLocalMcpServerEnabledRequest, SetLocalMcpServerToolEnabledRequest } from './local-mcp-server-api.js';
+export interface TargetMcpCatalog {
+    items: LocalMcpServer[];
+    revision: string;
+}
+export interface TargetModelCatalog {
+    items: LocalCustomModel[];
+    revision: string;
+}
+export type TargetModelCommand = {
+    expectedRevision: string;
+} & ({
+    action: 'save';
+    request: SaveLocalCustomModelRequest;
+} | {
+    action: 'remove';
+    request: string;
+});
+export type TargetMcpCommand = {
+    expectedRevision: string;
+} & ({
+    action: 'save';
+    request: SaveLocalMcpServerRequest;
+} | {
+    action: 'enable';
+    request: SetLocalMcpServerEnabledRequest;
+} | {
+    action: 'tool';
+    request: SetLocalMcpServerToolEnabledRequest;
+} | {
+    action: 'remove' | 'discover' | 'grant' | 'revoke';
+    request: string;
+});
+export interface TargetResourceMethods {
+    modelList: () => Promise<TargetModelCatalog>;
+    modelCommand: (command: TargetModelCommand) => Promise<{
+        catalog: TargetModelCatalog;
+        model?: LocalCustomModel;
+    }>;
+    mcpList: () => Promise<TargetMcpCatalog>;
+    mcpCommand: (command: TargetMcpCommand) => Promise<TargetMcpCatalog>;
+    models: () => Promise<{
+        models: AvailableChatModel[];
+        customModels: LocalCustomModel[];
+        warnings: string[];
+    }>;
+    skills: () => Promise<{
+        items: SkillMarketItem[];
+        warnings: string[];
+    }>;
+    plugins: LocalPluginApi['list'];
+    setPluginEnabled: LocalPluginApi['setEnabled'];
+    professions: (query: Parameters<ProfessionMarketApi['listInstalled']>[0]) => Promise<Awaited<ReturnType<ProfessionMarketApi['listInstalled']>> & {
+        warnings: string[];
+    }>;
+    prepareProfession: ProfessionMarketApi['prepareForLocalTask'];
+    recordProfessionUsage: ProfessionMarketApi['recordUsage'];
+    generateTitle: TaskInitializationApi['generateTitle'];
+    enhancePrompt: TaskInitializationApi['enhancePrompt'];
+    recommendModel: TaskInitializationApi['recommendModel'];
+    resolveModelForExecution: TaskInitializationApi['resolveModelForExecution'];
+}
+export type TargetResourceName = keyof TargetResourceMethods;
+export type TargetResourceScope = {
+    connectionId: string;
+    workspace: WorkspaceRef;
+} | {
+    task: TaskRef;
+};
+export interface TargetSkillSyncPlan {
+    id: string;
+    sourceName: string;
+    folderName: string;
+    sha256: string;
+    sizeBytes: number;
+    files: number;
+}
+export interface TargetExpertSyncPlan {
+    id: string;
+    expertId: string;
+    name: string;
+    version: string;
+    sha256: string;
+    sizeBytes: number;
+    files: number;
+    skills: Array<{
+        reference: string;
+        folderName: string;
+        sha256: string;
+        sizeBytes: number;
+        files: number;
+    }>;
+    warnings: string[];
+}
+export interface TargetResourcesApi {
+    invoke<K extends TargetResourceName>(scope: TargetResourceScope, method: K, args: Parameters<TargetResourceMethods[K]>): Promise<Awaited<ReturnType<TargetResourceMethods[K]>>>;
+}
+export declare const TARGET_RESOURCE_NAMES: readonly TargetResourceName[];

package/dist/shared/task-initialization-api.d.ts

@@ -0,0 +1,44 @@
+export interface GenerateTaskTitleRequest {
+    permissionMode?: 'ask_dangerous' | 'allow_all';
+    prompt: string;
+    projectId?: string;
+}
+export interface GenerateTaskTitleResult {
+    title: string;
+    model: string;
+}
+export interface EnhanceTaskPromptRequest {
+    permissionMode?: 'ask_dangerous' | 'allow_all';
+    prompt: string;
+    projectId?: string;
+}
+export interface EnhanceTaskPromptResult {
+    prompt: string;
+    model: string;
+}
+export interface RecommendTaskModelRequest {
+    permissionMode?: 'ask_dangerous' | 'allow_all';
+    prompt: string;
+    projectId?: string;
+    attachments?: Array<{
+        name: string;
+        mediaType: string;
+    }>;
+}
+export interface RecommendTaskModelResult {
+    model: string;
+    source: 'recommended' | 'default';
+}
+export interface ResolveTaskExecutionModelRequest extends RecommendTaskModelRequest {
+    recommendedModel?: string;
+}
+export interface ResolveTaskExecutionModelResult {
+    model: string;
+    source: 'existing' | 'recommended' | 'default';
+}
+export interface TaskInitializationApi {
+    generateTitle(request: GenerateTaskTitleRequest): Promise<GenerateTaskTitleResult>;
+    enhancePrompt(request: EnhanceTaskPromptRequest): Promise<EnhanceTaskPromptResult>;
+    recommendModel(request: RecommendTaskModelRequest): Promise<RecommendTaskModelResult>;
+    resolveModelForExecution(request: ResolveTaskExecutionModelRequest): Promise<ResolveTaskExecutionModelResult>;
+}

package/dist/shared/task-menu-api.d.ts

@@ -0,0 +1,27 @@
+export type TaskMenuTarget = {
+    kind: 'local';
+    taskId: string;
+} | {
+    kind: 'cloud';
+    taskId: string;
+    projectId: string;
+};
+export type TaskMenuAction = {
+    kind: 'new-task';
+} | TaskMenuTarget;
+export interface TaskMenuEntry {
+    target: TaskMenuTarget;
+    title: string;
+    projectName?: string;
+    updatedAt: string;
+    unread: boolean;
+}
+export interface TaskMenuSnapshot {
+    ownerUserId: string;
+    source: 'local' | 'cloud';
+    tasks: TaskMenuEntry[];
+}
+export interface TaskMenuApi {
+    update(snapshot: TaskMenuSnapshot): Promise<void>;
+    onAction(listener: (action: TaskMenuAction) => void): () => void;
+}

package/dist/shared/task-operation.d.ts

@@ -0,0 +1,19 @@
+/** A reference to the existing execution owner, never another task or scheduler. */
+export interface TaskOperationReference {
+    id: string;
+    sessionId: string;
+    runId: string;
+    kind: 'process' | 'document' | 'model-media';
+    ownerId: string;
+    createdAt: string;
+}
+export interface TaskOperationSnapshot {
+    reference: TaskOperationReference;
+    status: 'running' | 'completed' | 'failed' | 'cancelled' | 'unknown';
+    canCancel: boolean;
+    observedAt: string;
+    /** Actual owner response. This can include expiring remote download URLs; it is not browser-safe HTML. */
+    result?: unknown;
+    /** Unknown is not success or cancellation; e.g. a process owner exited without a terminal record. */
+    reason?: string;
+}

package/dist/shared/task-path-policy.d.ts

@@ -0,0 +1,14 @@
+/** Explicit host grants. Omitted policy preserves existing desktop/CLI task behavior. */
+export interface TaskPathPolicy {
+    cwd?: string;
+    readRoots: string[];
+    writeRoots: string[];
+    /** Elevated requires a sandbox already provisioned by the machine administrator. */
+    windowsSandbox?: 'unelevated' | 'elevated';
+}
+export interface ResolvedTaskPathPolicy extends TaskPathPolicy {
+    cwd: string;
+    workspaceRoot: string;
+    stateRoot: string;
+}
+export declare function parseTaskPathPolicy(value: unknown): TaskPathPolicy;